刷题笔记之链表

最新推荐文章于 2024-10-04 00:00:03 发布
最新推荐文章于 2024-10-04 00:00:03 发布
阅读量91 收藏
点赞数 1
分类专栏： 力扣刷题 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1244664276/article/details/117387120
版权
这篇博客探讨了链表数据结构，包括单链表和双链表的操作，如添加、删除结点，以及如何设计链表。文章重点讲述了双指针技巧在链表中的应用，例如在环形链表、寻找链表中点问题上的策略。还提供了多个相关编程题目的解题思路，如141.环形链表、142.环形链表2、160.相交链表等。
摘要由CSDN通过智能技术生成

文章目录

前言

本博客是对链表做相关练习时所做笔记，主要内容来源链表。

  • 与数组相似，链表也是一种线性数据结构。
  • 链表有两种类型：单链表和双链表。
  • 与数组相似，双指针技巧在链表中也常被使用。

文中主要介绍了单链表与双链表的基本操作，以及双指针在链表中的应用。后续会不断增加一些题目的练习。

单链表

  • 单链表中的每个结点不仅包含值，还包含链接到下一个结点的引用字段。通过这种方式，单链表将所有结点按顺序组织起来。

  • 结点结构

    // 单链表定义
public class SinglyListNode {
    int val; //值
    SinglyListNode next; //下一个结点的引用字段
    SinglyListNode(int x) { 
        val = x; 
    }
}

    在大多数情况下，我们将使用头结点(第一个结点)来表示整个列表。

  • 操作

    添加操作：让新来的结点有所指向

    1. 在给定的结点 prev 之后添加新结点cur

      链表1

      cur.next = prev.next;
prev.next = cur;

    2. 添加头结点

      cur.next = head;
head = cur;

    删除操作

    1. 从单链表中删除现有结点 cur

      找到 cur 的上一个结点 prev 及其下一个结点 next ；链接 prev 到 cur 的下一个节点 next 。

      prev.next = prev.next.next;

      因此，关键在于找到 cur 的上一个结点 prev，这个过程的时间复杂度为O(n)。

    2. 删除第一个结点

      想要删除第一个结点，可以简单地将下一个结点分配给 head。

  • 为了让第一个结点不再特殊，我们常常可以在链表最前面额外地添加一个哑结点或哨兵结点来作为头结点，这样结构永远不为空。其在树和链表中被广泛用作伪头、伪尾等，通常不保存任何数据，用来简化插入和删除操作。

707.设计链表

  • 题目描述：设计链表的实现。您可以选择使用单链表或双链表。假设链表中的所有节点都是 0-index 的。

  • 示例

    MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

  • 分析

    添加一个哨兵结点可大大简化操作。

  • 代码

    class Node {
    int val;
    Node next;
    public Node(int val) {
        this.val = val;
    }
}

class MyLinkedList {
    Node head; //头结点
    int size; //记录链表的大小

    /**
     * Initialize your data structure here.
     */
    public MyLinkedList() {
        head = new Node(0); //添加一个哨兵结点作为头结点，可简化操作
        size = 0;
    }

    /**
     * Get the value of the index-th node in the linked list. If the index is invalid, return -1.
     */
    public int get(int index) {
        if (index < 0 || index >= size) return -1;
        Node cur = head;
        for (int i = 0; i <= index; i++) {
            cur = cur.next;
        }
        return cur.val;
    }

    /**
     * Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
     */
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    /**
     * Append a node of value val to the last element of the linked list.
     */
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    /**
     * Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
     */
    public void addAtIndex(int index, int val) {
        if (index > size) return;
        if (index < 0) index = 0;
        //找到第index结点前面的那个结点
        Node prev = head;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        Node cur = new Node(val);
        cur.next = prev.next;
        prev.next = cur;
        size++;
    }

    /**
     * Delete the index-th node in the linked list, if the index is valid.
     */
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) return;
        //找到第index结点前面的那个结点
        Node prev = head;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        prev.next = prev.next.next;
        size--;
    }
}

双指针技巧

  • 我们在数组中已经使用过双指针技巧，有两种情况：
    1. 两个指针从不同位置出发：一个从始端开始，另一个从末端开始；
    2. 两个指针以不同速度移动：一个指针快一些，另一个指针慢一些。
  • 对于单链表，由于只能在一个方向上遍历链表，所以一般使用第二种即快慢指针。其在判断链表是否有环、寻找链表中点等问题上非常有用。

141.环形链表

  • 题目描述：给定一个链表，判断链表中是否有环。

    如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

    如果链表中存在环，则返回 true 。 否则，返回 false 。

  • 示例

    输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

  • 分析

    本题可直接用哈希表来判断结点是否再次出现即可，时间复杂度为O(n)，空间复杂度为O(n)。

    更优的解法就是使用快慢指针，初始时快慢指针都指向头结点。快指针每次走两步，慢指针每次走一步，如果能再次相遇，说明有环，否则，一直到快指针走到链表尾，证明无环。

    关键在于快慢指针的步长，不能过大，也不能过小。

  • 代码

    /**
 * 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 && fast.next != null) {
            //快指针每次走两步
            fast = fast.next.next;
            //慢指针每次走一步
            slow = slow.next;
            //两个指针相遇时证明有环
            if(fast == slow) {
                return true;
            }
        }

        return false;
    }
}

142.环形链表2

  • 题目描述：在环形链表的基础上，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

  • 示例

    输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点

  • 分析

    依旧使用快慢指针，快指针每次走两步，慢指针每次走一步。

    假设从头结点到入环点的距离为a，从入环点到相遇点(Q)的距离为b，从相遇点(Q)到入环点的距离为c，如下图：

    142题

    最后得到的等式为a=(n-1)(b+c)+c，其中b+c为环的长度，也就是说在相遇点时，如果我们将一个指针first指向头结点，与慢指针同时移动，最终会在入环点相遇，此时first走了a的距离，慢指针走了n-1圈加上c。

  • 代码

    /**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        ListNode first = head;
        while(fast!=null && fast.next!=null) {
            fast = fast.next.next;
            slow = slow.next;
            //到达相遇点
            if(fast == slow) {
                //first必与slow在入环的第一个结点相遇
                while(first != slow) {
                    first = first.next;
                    slow = slow.next;
                }
                return first;
            }
        }
        return null;
    }
}

160.相交链表

  • 题目描述：编写一个程序，找到两个单链表相交的起始节点。如果两个链表没有交点，返回null，假定链表没有循环。

  • 分析

    比较直观的思路就是首先比较两个链表的长度，然后让较长链表的头结点指针往后移，直至剩余的结点长度与较短的链表长度一致，之后两个链表的头结点同时移动，直至指向相同的结点，即找到了交点。这种方法代码写起来比较繁琐，因为需要求两个链表的长度，并判断它们的长短。

    一种较为简单的方法就是首先创建两个指针p1和p2，分别指向链表A和B的头结点，同时向后遍历；若p1到达尾部，则让它重新指向链表B的头结点，若p2到达尾部，则让它重新指向链表A的头结点，最终它们会相遇在交点。原理如下图：

    在这里插入图片描述

    p1走过的距离为a+c+b，p2走过的距离为b+c+a，最终相遇在交点。

  • 代码

    /**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA;
        ListNode p2 = headB;
        while(p1 != p2) {
            //p1到达尾部，则让它重新指向链表B的头结点
            if(p1 == null) p1 = headB;
            else p1 = p1.next;
            //p2到达尾部，则让它重新指向链表A的头结点
            if(p2 == null) p2 = headA;
            else p2 = p2.next;
            
        }
        return p1;
    }
}

19.删除链表的倒数第 N 个结点

  • 题目描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

  • 示例

    输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

  • 分析

    本题依旧是双指针技巧在链表中的典型应用。

    要找到倒数第n个结点，我们可以考虑先使一个指针指向正数第n个结点，然后再令另一个指针指向头结点，使两个指针同时移动，当第一个指针到达链表最后一个结点时，后一个指针恰好指向倒数第n个结点。

    而我们要删除此结点，就必须找到其前一个结点，因为涉及到删除操作，为了使第一个结点不再特殊，我们首先可以考虑增加一个哑结点。只要我们将第二个指针初始时指向哑结点，就能找到要删除结点的前一个结点。

  • 代码

    /**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //增加一个哨兵结点作为头结点
        ListNode dummy = new ListNode(0,head);
        ListNode p1 = dummy, p2 = dummy;
        //使p2指向正数第n个结点
        for(int i=0; i<n; i++) {
            p2 = p2.next;
        }
        //p1，p2同时移动，p2到达尾结点时，p1到达倒数第n个结点前一个结点
        while(p2.next != null) {
            p1 = p1.next;
            p2 = p2.next;
        }
        //删除
        p1.next = p1.next.next;
        return dummy.next;
    }
}

双链表

  • 与单链表不同的是，双链表的每个结点中都含有两个引用字段。

  • 结点结构

    class DoublyListNode {
    int val;
    DoublyListNode next, prev;
    DoublyListNode(int x) {val = x;}
}

    与单链表一样，也是使用头结点来表示整个列表。

  • 操作

    • 添加操作：在现有的结点 prev 之后插入一个新的结点 cur。

      链表2

      //首先将 cur 与 prev 和 next(prev的下一个结点)连接
cur.next = prev.next;
cur.prev = prev;
//再处理剩余指向
prev.next = cur;
cur.next.prev = cur;

      对于开头和结尾，除了可以分情况处理外，也可以使用虚拟头结点和尾结点，添加操作就统一了。

    • 删除操作：删除一个现有的结点 cur。

      与单链表不同，使用prev字段可以很容易地在常量时间内获得前一个结点。

      cur.prev.next = cur.next;

      对于开头和结尾，除了可以分情况处理外，也可以使用虚拟头结点和尾结点，删除操作就统一了。

题目练习

206.反转链表

  • 题目描述：给你单链表的头结点 head ，请你反转链表，并返回反转后的链表。链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

  • 分析：

    对于迭代法，可以从前往后遍历链表，把当前结点移出链表并插到链表的头部（头插法），这样一次遍历就完成了链表的反转。需要注意的细节就是为了能找到下一个要遍历的结点，我们可以增加一个指针prev，指向要遍历的结点的前一个结点。

    对于递归，相对来说复杂一点，假设链表的其余部分已经被反转，那么关键就在于如果反转前面的部分。对于当前结点cur，如果它后面的部分已经反转，要反转它，就要使cur.next.next = cur; cur.next = null;

  • 代码

    迭代方式

    class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null || head.next==null) return head;

        ListNode prev = head, cur = head.next;
        while(cur != null) {
            //将当前结点移出链表
            prev.next = cur.next;
            //将当前结点插到头部
            cur.next = head;
            head = cur;
            cur = prev.next;
        }

        return head;
    }
}

    递归方式

    class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null || head.next==null) return head;
        //反转链表的其余部分
        ListNode newHead = reverseList(head.next);
        //对当前结点进行反转
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

203.移除链表元素

  • 题目描述：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

  • 分析

    较为简单，需要注意的是涉及的增删操作加一个虚拟头结点往往更加简单。

  • 代码

    class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(0,head);
        ListNode prev = dummy;
        while(prev.next != null) {
            //等于val时删除结点
            if(prev.next.val == val) {
                prev.next = prev.next.next;
            }else{
                //不等于val时就往后移动
                prev = prev.next;
            }
        }
        return dummy.next;
    }
}

328.奇偶链表

  • 题目描述：给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。请尝试使用原地算法完成。

  • 示例

    输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

  • 分析

    我们可以通过迭代的方式将奇数结点和偶数结点分离成奇数链表和偶数链表，然后将偶数链表连接在奇数链表之后，合并后的链表即为结果链表。

    在迭代的过程中，对于每一对奇偶结点，由于奇数结点在偶数结点前面，因此每一步首先更新奇数结点，然后更新偶数结点。

  • 代码

    class Solution {
    public ListNode oddEvenList(ListNode head) {
        if(head==null || head.next==null) return head;
        //奇数结点的指针
        ListNode odd = head;
        //偶数结点的指针
        ListNode evenHead = head.next, even = evenHead;

        //通过迭代的方式将奇数结点和偶数结点分离成两个链表
        while(even!=null && even.next!=null) {
            //更新奇数结点
            odd.next = even.next;
            odd = odd.next;
            //更新偶数结点
            even.next = odd.next;
            even = even.next;
        }
        //合并奇偶链表
        odd.next = evenHead;
        
        return head;
        
    }
}

234.回文链表

  • 题目描述：请判断一个链表是否为回文链表。

  • 示例

    输入: 1->2
输出: false
输入: 1->2->2->1
输出: true

  • 分析

    如果不考虑空间复杂度，我们可以直接将链表转化为数组，然后再判断就非常简单了。

    而如果要就地判断，可以参考206题反转链表，我们可以先找到链表中点，然后将链表中点后的结点反转，再通过双指针比较判断就非常简单了。当然，最后可以再将链表结构恢复，不过本题未做要求。

  • 代码

    class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head==null || head.next==null) return true;
        //使用快慢指针找到前半部分的尾结点
        ListNode slow=head, fast=head.next;
        while(fast!=null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        //反转后半部分链表
        slow.next = reverseList(slow.next);
        ListNode cur = slow.next;
        //判断是否是回文
        while(cur != null) {
            if(head.val != cur.val) return false;
            head = head.next;
            cur = cur.next;
        }
        //恢复链表
        slow.next = reverseList(slow.next);
        return true;
    }
    //反转链表
    public ListNode reverseList(ListNode head) {
        if(head==null || head.next==null) return head;
        ListNode prev = head, cur = head.next;
        while(cur != null) {
            //将当前结点移出链表
            prev.next = cur.next;
            //将当前结点插到头部
            cur.next = head;
            head = cur;
            cur = prev.next;
        }
        return head;
    }
}
zhb2go
关注
专栏目录
【Leetcode刷题笔记之链表篇】234. 回文链表
大家好我叫张同学
01-15 1257
给你一个单链表的头节点 `head` ，请你判断该链表是否为`回文链表`。 如果`是`，返回 `true` ；否则，返回` false` 。 具有对称性的链表就具有回文结构 如果是单数个结点，中间的结点无需考虑，如果其他结点对称肯定是回文结构 例如：1 2 3 1 2 也是回文结构 这里借助求链表倒数第k个结点的思路。 只要链表的.....
【Leetcode刷题笔记之链表篇】141. 环形链表
大家好我叫张同学
01-18 907
给你一个链表的头节点 `head` ，判断链表中`是否有环`。 如果链表中有某个节点，可以通过`连续跟踪` `next `指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数` pos `来表示链表尾连接到链表中的位置（索引从` 0` 开始）。如果` pos` 是` -1`，则在该链表中没有环。 注意：`pos` 不作为参数进行传递，仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回 `true` 。 否则，返回 `false` 。
代码随想录——力扣刷题笔记之链表
m0_49651195的博客
03-18 1075
在这里我使用Python来定义链表节点方式，采用函数的方式（参考力扣上给出的方式）
LeetCode刷题笔记之链表
abtgu的博客
12-08 521
LeetCode刷题笔记之链表
刷题笔记之链表内指定区间反转
weixin_63162063的博客
06-28 154
完成了反转就可以开始连接了，这时候又需要两个指针，tmp3用于进行连接，newList用于返回结果，先判断反转的链表包不包括原链表的头节点，对那部分的链表进行反转，此时前面标记的两个指针就起到作用了，tmp1用于确定反转部分链表的头，tmp2用于最后判断是否已经完成反转。那就让tmp3和newList直接等于反转后的链表头即a指针，因为此时的a已经确定为最终结果的头节点了（原来的头结点被转后面去了）。定义两个标记指针，tmp1：保存反转的起始位置，tmp2：保存反转的结束位置的下一个。
【Leetcode刷题笔记之链表篇】160. 相交链表
大家好我叫张同学
01-16 909
给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表`相交`的`起始节点`。如果两个链表`不存在`相交节点，返回 `null `。 图示两个链表在节点 c1 开始相交：理解相交：不是指A链表中有和B链表中val值相同的结点，而是指这个两个链表中存在相同的结点，如果我们通过指针去遍历A、B两个链表，能够在A、B中找到相同地址的结点，那A、B相交，否则就是不相交。
【Leetcode刷题笔记之链表篇】面试题 02.04. 分割链表
大家好我叫张同学
01-13 836
总体而言，要想实现分割链表的目的有两种大的思路。一种是`不创建新的链表`，直接在`原链表`上面进行相应的操作。另一种是`创建一个新的链表`，将原来的链表`挪到`新链表中，同时达到想要的效果。
【Leetcode刷题笔记之链表篇】206. 反转链表
大家好我叫张同学
01-09 1389
要反转链表，一个很容易想到的方法就是：直接将链表结点之间的链接关系`反过来`。例如原来为`1->2`,反过来就是`1<-2`,也就是`2->1`。 除了使用这种迭代的方式之外，我们还可以使用头插法。将原来的链表`头插`到一个新的链表中，那么链表的方向就会反过来。 除了以上两者方式外，还有一种递归实现的方法，递归版本稍微复杂一些，其关键在于反向工作。 假设列表的其余部分已经被反转，现在我们应该如何反转它前面的部分？
【Leetcode刷题笔记之链表篇】876. 链表的中间结点
大家好我叫张同学
01-10 1147
给定一个头结点为 `head` 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 要得到中间结点，我们很容易想到的一种方法就是：先`遍历一遍链表`，求出`链表长度`，然后再从头开始，`走到中间结点`去，返回中间结点......
【Leetcode刷题笔记之链表篇】142. 环形链表 II
大家好我叫张同学
01-20 1139
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 如果链表中有某个节点，可以通过连续跟踪 `next `指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数` pos` 来表示链表尾连接到链表中的位置（索引从` 0` 开始）。如果 pos 是` -1`，则在该链表中没有环。 注意：`pos `不作为参数进行传递，仅仅是为了标识链表的实际情况。`不允许修改` 链表。
数据结构（二叉树）
最新发布
2301_80475151的博客
10-04 1019
数据结构的二叉树、顺序结构的树和链式结构的树的实现
【笔记】数据结构12
m0_52024881的博客
09-29 595
看到的社区的一个知识总结，这里记录一下。
数据结构之树（3）
2301_76246515的博客
09-29 402
重要！树->二叉树由于孩子兄弟链式存储和二叉树链式存储本质相同，故树可转换为二叉树。森林->二叉树森林：m棵互不相交的树的集合森林->树 树->二叉树森林中各个树的根节点之间视为兄弟关系。
栈数据结构:定义，基本操作与应用
m0_66847953的博客
10-03 869
栈（Stack）是一种特殊的线性数据结构，其插入和删除操作都只允许在表的一端进行。这一端被称为栈顶（top），另一端则被称为栈底（bottom）。栈遵循后进先出（Last In First Out，LIFO）的规则，即最后存入的元素将被最先取出。顺序栈采用一个数组存放栈中的元素。如果需要用到两个类型相同的栈，这时若为它们各自开辟一个数组空间,极有可能出现这样的情况：第一个栈已满,再进栈就溢出了，而另一个栈还有很多空闲的存储空间。解决这个问题的方法是。
Java.数据结构.TreeSet
TJKFYY的博客
10-03 221
TreeSet是Java集合框架中的一部分，是基于TreeMap实现的。TreeSet保证了集合中的元素按照自然顺序或者通过提供的Comparator进行排序。：TreeSet会根据元素的自然顺序进行排序，确保集合中的元素总是处于有序状态，和TreeMap一样，我们同样可以通过重写Comparator方法来进行排序。：TreeSet中的元素是唯一的，不能重复。如果有两个元素相等，则后插入的元素不会出现在集合中。：TreeSet基于TreeMap实现，其时间复杂度为O(log n)。
高阶数据结构-------图
2301_76560014的博客
10-02 1103
构造一个含n个顶点、不含任何边的图作为最小生成树，将图中的顶点分为两个集合，forest集合中的顶点是已经连接到最小生成树中的顶点，remain集合中的顶点是还没有连接到最小生成树中的顶点，刚开始时forest集合中只包含给定的起始顶点。每次从连接forest集合与remain集合的所有边中选出一条权值最小的边，将其加入到最小生成树中，由于选出来的边对应的两个顶点一个属于forest集合，另一个属于remain集合，因此是不会构成回路的。图由顶点和边组成，存储图本质就是将图中的顶点和边存储起来。
【笔记】选择题笔记+数据结构笔记
m0_52024881的博客
09-30 608
连通分量是极大连通子图一个连通图的生成树是一个极小连通子图。
JAVA并发编程高级——JDK 新增的原子操作类 LongAdder
weixin_45826852的博客
09-29 376
既然 AtomicLong的性能瓶颈是由于过多线程同时去竞争一个变量的更新而产生的，那么如果把一个变量分解为多个变量，让同样多的线程去竞争多个资源,是不是就解决了性能问题?使用AtomicLong 时，在高并发下大量线程会同时去竞争更新同一个原子变量，但是由于同时只有一个线程的CAS操作会成功，这就造成了大量线程竞争失败后，会通过无限循环不断进行自旋尝试CAS 的操作，而这会白白浪费 CPU 资源。如图 4-1所示，使用 AtomicLong时，是多个线程同时竞争同一个原子变量。
力扣刷题笔记：反转链表与LRU缓存
"力扣500题刷题笔记4，涉及两道LeetCode上的经典链表问题：206.反转链表和146.LRU缓存机制" 在这篇刷题笔记中，作者首先讨论了LeetCode上的第206题——反转链表。反转链表是一个常见的链表操作，其目标是将链表中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值