牛客top100 - 自刷打卡day1 - 链表

已于 2023-03-19 23:50:50 修改
阅读量766 收藏
点赞数
分类专栏： 刷题个人打卡 文章标签： 链表 java 数据结构
于 2023-03-19 21:20:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_50546235/article/details/129656743
版权
本文介绍了链表的多种操作，包括反转链表、指定区间反转、按k个节点翻转、合并两个及多个已排序链表、判断链表是否有环以及找到环的入口节点、找到链表中倒数k个节点、删除倒数第n个节点、查找两个链表的第一个公共节点、链表相加、排序链表、判断回文结构、奇偶重排以及删除重复元素的方法。这些算法涉及数据结构和算法设计，适用于编程面试和练习。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

top100-打卡day1

链表

BM1反转链表

反转链表_牛客题霸_牛客网 (nowcoder.com)

  • 秒
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if (head == null)
            return head;
        ListNode pre = null;
        ListNode cur = head;
        while (cur !=  null && cur.next != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        cur.next = pre;
        return cur;
    }

}

BM2链表内指定区间反转

链表内指定区间反转_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head ListNode类
     * @param m int整型
     * @param n int整型
     * @return ListNode类
     */
    //        p   c   n
    //    2       4
    //1-->2-->3-->4-->5-->null
    public ListNode reverseBetween (ListNode head, int m, int n) {
        int num = n - m;//2
        if (num <= 0 ) return head;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pre = dummy;
        while ((--m) != 0) {
            pre = pre.next;
        }
        ListNode lHead = pre;
        ListNode lCur = pre.next;
        ListNode cur = pre.next;
        while (num != 0) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
            num--;
        }
        ListNode next = cur.next;
        cur.next = pre;
        lHead.next = cur;
        lCur.next = next;
        return dummy.next;
    }
}

BM3链表中的节点每k个一组翻转

链表中的节点每k个一组翻转_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head ListNode类
     * @param k int整型
     * @return ListNode类
     */
    public ListNode reverseKGroup (ListNode head, int k) {
        int m = k;
        // write code here
        if (head == null) return head;
        ListNode pHead = head;
        for (int i = 0; i < k; i++) {
            if (pHead == null) {
                return head;
            }
            pHead = pHead.next;
        }
        ListNode pre = null;
        ListNode cur = head;
        while((m--) != 0) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        head.next = reverseKGroup(pHead, k);
        
        return pre;


    }
}

BM4合并两个排序的链表

合并两个排序的链表_牛客题霸_牛客网 (nowcoder.com)

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1, ListNode list2) {
        ListNode l1 = list1;
        ListNode l2 = list2;
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val >= l2.val) {
                cur.next = l2;
                l2 = l2.next;
                cur = cur.next;
            } else {
                cur.next = l1;
                l1 = l1.next;
                cur = cur.next;
            }
        }
        if (l1 != null) {
            cur.next = l1;
        }
        if (l2 != null) {
            cur.next = l2;
        }
        return dummy.next;

    }
}

BM5合并k个已排序的链表

合并k个已排序的链表_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
     public ListNode Merge(ListNode list1, ListNode list2) {
        ListNode l1 = list1;
        ListNode l2 = list2;
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val >= l2.val) {
                cur.next = l2;
                l2 = l2.next;
                cur = cur.next;
            } else {
                cur.next = l1;
                l1 = l1.next;
                cur = cur.next;
            }
        }
        if (l1 != null) {
            cur.next = l1;
        }
        if (l2 != null) {
            cur.next = l2;
        }
        return dummy.next;

    }
    public ListNode mergeKLists(ArrayList<ListNode> lists) {
        return divideMerge(lists, 0, lists.size() -1);
    }
    ListNode divideMerge(ArrayList<ListNode> lists, int left, int right){
        if(left > right ){
            return null;
        }
         if(left == right) {
            return lists.get(left);
        }
        int mid = left + right >> 1;
        return Merge(divideMerge(lists, left, mid), divideMerge(lists, mid + 1, right));
    }
}

BM6判断链表中是否有环

判断链表中是否有环_牛客题霸_牛客网 (nowcoder.com)

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && slow != null) {
            if(fast.next != null) {
                fast = fast.next.next;
            }else{
                return false;
            }
            slow = slow.next;
            if(slow == fast) {
                return true;
            }
        }
        return false;
    }
}

BM7链表中环的入口结点

链表中环的入口结点_牛客题霸_牛客网 (nowcoder.com)

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        if(pHead.next == null) return null;
        ListNode fast = pHead;
        ListNode slow = pHead;
        while(fast != null && slow != null) {
            if(fast.next != null){
                fast = fast.next.next;
            }else{
                return null;
            }
            slow = slow.next;
            if(fast == slow) {
                break;
            }
        }
        if(fast == null || slow == null) return null;
        fast = pHead;
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

BM8链表中倒数最后k个结点

链表中倒数最后k个结点_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pHead ListNode类
     * @param k int整型
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        ListNode pre = pHead;
        ListNode cur = pHead;
        int tk = k;
        while (pre != null && (tk--) != 0) {
            pre = pre.next;
        }
        if(pre == null && tk > 0) return null;
        while(pre != null) {
            pre = pre.next;
            cur = cur.next;
        }
        return cur;
        
    }
}

BM9删除链表的倒数第n个节点

删除链表的倒数第n个节点_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head ListNode类
     * @param n int整型
     * @return ListNode类
     */
    public ListNode removeNthFromEnd (ListNode head, int n) {
        // write code here
        int tn = n;
        ListNode cur = new ListNode(-1);
        cur.next = head;
        ListNode pre = head;
        ListNode red = cur;
        while (pre != null && (--tn) != 0) {
            pre = pre.next;
        }
        if (pre != null && tn > 0) return null;

        while (pre.next != null) {
            pre = pre.next;
            cur = cur.next;
        }
        cur.next = cur.next.next;
        return red.next;
    }
}

BM10两个链表的第一个公共结点

两个链表的第一个公共结点_牛客题霸_牛客网 (nowcoder.com)

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        while(p1 != p2){
            p1 = p1 == null ? pHead2 : p1.next;
            p2 = p2 == null ? pHead1 : p2.next;
        }
        return p1;

    }
}

BM11链表相加(二)

链表相加(二)_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head1 ListNode类
     * @param head2 ListNode类
     * @return ListNode类
     */
    public ListNode reverseList(ListNode head) {
        if (head == null) return head;
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
    public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
         head1 = reverseList(head1);
         head2 = reverseList(head2);
        ListNode h1 = head1;
        ListNode h2 = head2;
        int pVal = 0;
        ListNode res = new ListNode(-1);
        ListNode rHead = res;
        while (h1 != null && h2 != null) {
            int val = h1.val + h2.val + pVal;
            pVal = val >= 10 ? val / 10 : 0;
            val = val % 10;
            res.next = new ListNode(val);
            res = res.next;
            h1 = h1.next;
            h2 = h2.next;
        }
        while (h1 != null) {
            int val = pVal + h1.val;
            pVal = val >= 10 ? val / 10 : 0;
            val = val % 10;
            res.next = new ListNode(val);
            res = res.next;
           h1 = h1.next;
        }
        while (h2 != null) {
            int val = pVal + h2.val;
            pVal = val >= 10 ? val / 10 : 0;
            val = val % 10;
            res.next = new ListNode(val);
            res = res.next;
             h2 = h2.next;
        }
        if(pVal != 0) {
            res.next = new ListNode(pVal);
        }

        return reverseList(rHead.next);
    }
}

BM12单链表的排序

单链表的排序_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head ListNode类 the head node
     * @return ListNode类
     */
    public ListNode sortInList (ListNode head) {
        // write code here
        PriorityQueue<ListNode> queue = new PriorityQueue<>(new Comparator<ListNode>() {
            public int compare(ListNode o1, ListNode o2) {
                return o1.val - o2.val;
            }
        });
        ListNode cur = head;
        while (cur != null) {
            
            queue.offer(cur);
            cur = cur.next;
        }
        ListNode res = new ListNode(-1);
        ListNode rHead = res;
        while (!queue.isEmpty()) {
            res.next = queue.poll();
            res = res.next;
        }

        res.next = null;
        return rHead.next;

    }
}

BM13判断一个链表是否为回文结构

判断一个链表是否为回文结构_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    public ListNode reverseList(ListNode head){
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
    public boolean isPail (ListNode head) {
        if(head == null || head.next == null) return true;
        // write code here
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode rHead = reverseList(slow);
        ListNode lHead = head;
        while(lHead != null && rHead != null) {
            if(lHead.val != rHead.val){
                return false;
            }
            lHead = lHead.next;
            rHead = rHead.next;
        }
        return true;
    }
}

BM14链表的奇偶重排

链表的奇偶重排_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode oddEvenList (ListNode head) {
        // write code here
        ListNode J = new ListNode(-1);
        ListNode O = new ListNode(-1);
        ListNode cj = J;
        ListNode co = O;
        ListNode cur = head;
        boolean flag = false;
        while(cur != null) {
            if(flag) {
                co.next = cur;
                co = co.next;
                flag = ! flag;
            }else{
                cj.next = cur;
                cj = cj.next;
                flag = ! flag;
            }
            cur = cur.next;
        }
        co.next = null;
        cj.next = O.next;
        return J.next;
    }
}

BM15 删除有序链表中重复的元素-I

删除有序链表中重复的元素-I_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode deleteDuplicates (ListNode head) {
        if(head == null) return head;
        // write code here
        ListNode dummy = new ListNode(-1);
        dummy.next = head; 
        ListNode cur = head;
        ListNode next = cur.next;
        if(next == null) return head;
        while(next != null){
            if(cur.val == next.val){
                cur.next = next.next;
            }else{
                cur = next;
            }
            next = next.next;
        } 

        return dummy.next;
    }
}

BM16 删除有序链表中重复的元素-II

删除有序链表中重复的元素-II_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head ListNode类
     * @return ListNode类
     */
    public ListNode deleteDuplicates (ListNode head) {
        // write code here
        if (head == null) return null;
        ListNode pre = new ListNode(-1);
        pre.next = head;
        ListNode resHead = pre;
        ListNode cur = head;
        ListNode next = cur.next;
        if (next == null) return head;
        while (next != null) {
            if (cur.val == next.val) {
                while (next != null && cur.val == next.val) {
                    next = next.next;
                }
                cur = next;
                if (next != null) {
                    next = next.next;
                }
                pre.next = cur;
            } else {
                pre = cur;
                cur = next;
                next = next.next;
            }
        }
        return resHead.next;
    }
}
2025最新华为OD机试真题目录A+B+C+D+E卷(持续收录中)-Java版
**My Coding Family**
02-12 2366
🔔本文收录于「最新最全华为OD机试真题(Java版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！专栏所写题库均搜集于互联网，经过精心筛选和整理，结合数位十多年大厂实战经验资深大佬经验所撰，欢迎订阅。    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可
华为OD机试统一考试D卷C卷 - 机器人仓库搬砖 py
华鑫的专栏
06-27 1017
爱贝生的奖金制度旨在激励每一个参与者，不仅是为了个人的收益，更是为了团队的发展和壮大。水实习到点下班就跑，希望回去能多学点，实习实际工作没什么含金量，但是实习下班回去之后其实又没太多精力。30min，面试官没有开摄像头，大概有三个人自我介绍项目介绍，你负责哪些部分MCU选型什么是PID有。公司岗位：滴滴 自动驾驶数据分析实习生工作强度：5天/周，3个月起步，据说实习生灵活打卡，早9晚7个。7V1，问问题的4个人，从进去自我介绍，结束后一直问问题，四个面试官轮流问，问研究内容，问技术，问研。
牛客top100 -自刷打卡day2+3 - 二叉树
m0_50546235的博客
03-21 431
day2+3 自刷打卡 - 二叉树
牛客java选择题每日打卡Day2
qq_46272491的博客
05-14 944
牛客java选择题每日打卡Day2 👩‍💻博客主页：京与旧铺的博客主页 ✨欢迎关注🖱点赞🎀收藏⭐留言✒ 🔮本文由京与旧铺原创，csdn首发！ 😘系列专栏：java学习 👕参考网站：牛客网 💻首发时间：🎞2022年5月14日🎠 🎨你做三四月的事，八九月就会有答案，一起加油吧 🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦 🎧最后的话，作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲 🛒导航小助手🎪 文章目录牛客java选择题每日打卡Day2🛒导航小助手🎪@[toc]🤶选择
牛客java选择题每日打卡Day15
qq_46272491的博客
06-25 459
第一步，func(1)，if条件不成立，不抛出异常，catch不运行，final运行，拼串得到“1”，程序继续往下走，拼串得到“12”。 第二步，fun(2)，if条件成立，抛出异常，catch捕获异常，运行catch里面代码，拼串得到“120”，虽然有return，但是不管出不出异常，final里代码必须执行，执行final，拼串得到“1201”，然后return结束。所以最终结果“1201”。list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍
牛客题霸（语法篇）--python入门题单及答案
m0_74261826的博客
10-28 741
本博客整理于本人所写的“牛客题霸（语法篇）--python入门题单”，文章中给出具体题目和答案,可以用于回顾python基础语法，夯实python基础，适用于刚入门python的新手和长时间不使用python，希望快速回忆python基础使用的老手进行回顾。
剑指offer打卡day03：二叉搜索树与双向链表 & 扑克牌顺子
COOLGWAYNE_TECH_BLOG
01-02 279
题1：二叉搜索树与双向链表 题目描述 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 说明：本题目包含复杂数据结构TreeNode，点此查看相关信息 解析： 双向链表： 在没有特指的情况下说链表一般指代“单向链表”，只能进行单项遍历，万一不行其中有一个链接断裂，那么后面的链表数据就无法复原了。 双向链表（Double LinkedList）在一个节点有两个指针变量，一个指向后面节点，一个指向前面的节点，可以双向通行。 优缺点： 优
题解 | #删除有序链表中重复的元素-II#
2301_79125642的博客
06-07 1056
1.银联商务陕西分公司，工作地点在西安，薪资8.5k，有年终奖，年包下来10w。1.银联商务陕西分公司，中国银联下属的子公司，薪资8.5k，有年终奖。刷到个大佬牛，真的是校招大满贯收官啊集齐腾讯、淘天、美团、字节四家天花板大厂不说，还有微软！本人双非本硕，目前还没论文，也没有实习，老师是做机器视觉的，给了一个偏图像处理算法的课题，感觉太学术。暑期实习，后端被挂完了，然后等了一个月被团子的移动端捞起来了，当时还没offer就接了。工位就在带教旁边，另一边也是我们组的正式员工，坐在工位上胳膊肘都能碰胳膊肘。
剑指offer打卡Day13：孩子们的游戏
COOLGWAYNE_TECH_BLOG
01-14 201
题1：圆圈中最后剩下的数 题目描述 每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。 HF作为牛客的资深元老,自然也准备了一些小游戏。 其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)
Week3-Day6 | 在打劫劫舍(1)上分类讨论
每天多一点干货
06-15 1418
面试的时候，问月期望薪资多少，自己说了 n，结果 offer 下来，给开了 n+6k，为啥(๑•̌.非常极限的一天盒马电话一面，上来先拷打项目，但是面试官很好，不像是那种冷冰冰的一问一答，像是在交流技。4月18开始投的第一个，断断续续投了几个，五月多了还在投，真的是太晚了，投的也太少了，真的是对现实情。985硕士，最近秋招，经朋友内部推荐，推荐到了佛山大家，简一陶瓷有限公司，数据分析岗，12k*12，本硕双非，本科科班，硕士调剂到水利来了（研0还没开学），想抽空重新把本科的Java捡起来，找实习再找。
题解 | #删除有序链表中重复的元素-I#原地复制链表比清晰
华鑫的专栏
04-26 575
投了产品数据工程实习生，已做完测评、笔试，现在都没有反应，求hr捞一波，沟通面试流程base可成都、1、自我介绍2、挖项目，简历写了两个项目，问我想挖哪个，我说游戏那个。投的后端，某书上次笔试a了3.5/4道，过了一个周没动静突然叫我笔试。1、自我介绍2、简历上项目详述，然后提问讨论3、为什么没有留在上一家公司实习，实习工资是多少4、中断。一面4.17 一个小时,电话面试1. 地图首屏优化怎么做的2. 优化做的挺多的,另一个怎么做的?刚接到团子的电话，但我昨天已经接了得物的offer，现在很。
使用Spring Boot和Spring Security构建安全的RESTful API
intwei的博客
05-17 745
本文详细介绍了如何使用Spring Boot和Spring Security构建安全的RESTful API，并结合JWT实现身份验证与授权。通过实际代码示例，帮助开发者快速上手。完整的项目代码可以在GitHub上找到。
上集：一个前端的血泪复仇记 —— 静态部署的胜利
十步杀一人-千里不留行
05-17 1229
在《上集：一个前端的血泪复仇记 —— 静态部署的胜利》中，作者分享了在部署一个前后端分离的小项目时遇到的挑战和解决方案。项目后端使用Spring Boot，前端使用Next.js。在部署过程中，前端静态资源的处理成为主要难题。作者通过将Next.js生成的静态文件直接放入Spring Boot的static目录，简化了部署流程。然而，Spring Security的默认配置阻止了对这些静态资源的访问，导致403错误。通过调整SecurityConfig和WebConfig，作者成功解决了这一问题。此外，前端
WEB安全--Java安全--CC1利用链
m0_74800552的博客
05-14 1533
CC1利用链的原理与构建方式
HashSet
weixin_51718998的博客
05-15 869
（1）HashSet的去重机制：hashCode()+equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals[遍历]比较，如果比较后，不相同就加入，否则就不加入。在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：1）先判断存储的类型（一组对象[单列]或一组键值对[双列]）map.put("no1","hahaha");
Java大厂求职面试：探讨Spring Boot与微服务架构
linuxjavac6的博客
05-18 617
谢飞机：嗯，Spring Boot和WebSocket可以结合使用来创建实时通信应用。谢飞机：可以采用微服务架构，使用Spring Cloud进行服务拆分和负载均衡。谢飞机：STOMP是一个简单的文本导向消息协议，可以用于WebSocket的消息传输。谢飞机：可以用Spring Security进行访问控制，结合OAuth2进行认证……张老师：电商平台需要处理大量的订单数据，你会如何设计数据库架构以支持快速查询和写入？张老师：在线教育平台需要支持大量视频存储和检索，你会如何设计系统架构。
部署springBoot项目的脚本-linux
zilin-lynn的博客
05-19 255
说明，maven打包时，可以将脚本打包跟jar包在同一个目录。
Java—— File详解
最新发布
zjy_ccccc的博客
05-19 419
说明，获取File对象。File的常见成员方法：判断、获取，创建、删除，获取并遍历：核心方法，其他方法。案例练习：利用递归的思想查找文件，利用递归的思想计算文件夹的大小，利用递归的思想删除有内容的文件夹
从卡顿到丝滑：JavaScript性能优化实战秘籍
zhengddzz的博客
05-15 952
JavaScript 性能优化是一个持续且综合性的过程，它贯穿于 Web 开发的整个生命周期。通过对代码结构的精心优化，如精简全局变量、巧用事件委托和打磨循环逻辑，可以从根源上提升代码的执行效率，减少不必要的性能开销。在内存管理方面，杜绝内存泄漏，优化对象的创建与销毁，确保程序能够高效地利用内存资源，避免因内存问题导致的性能下降。
牛客SQL练习题1-61答案详解
标题“牛客SQL练习题及答案（1-61题）”和描述“牛客SQL练习题及答案（1-61题）”所指向的知识点集中在SQL（Structured Query Language，结构化查询语言）的实践与应用，这是用于管理和操作关系数据库的标准语言。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值