链表面试题总结

柔情只为你懂 2022-12-24 15:58 163阅读 0赞

### 文章目录 ###

*   *  剑指 Offer 06. 从尾到头打印链表
     *   *  利用栈
         *  逆向输入数组
     *  剑指 Offer 24. 反转链表
     *   *  迭代解法
         *  递归解法
     *  剑指 Offer 18. 删除链表的节点
     *   *  解法
     *  删除排序链表中的重复元素
     *   *  解法1
         *  解法2
         *  递归
     *  删除链表的倒数第N个节点
     *   *  解法
     *  剑指 Offer 22. 链表中倒数第k个节点
     *   *  快慢指针
     *  剑指 Offer 35. 复杂链表的复制
     *   *  解法
     *  剑指 Offer 52. 两个链表的第一个公共节点
     *   *  解法
     *  合并两个有序链表
     *   *  非递归解法
         *  递归解法
     *  两两交换链表中的节点
     *   *  解法
     *  两数相加 II
     *   *  解法
     *  回文链表
     *   *  解法
         *  解法2
     *  分隔链表
     *   *  解法
     *  奇偶链表
     *   *  解法1
         *  解法2
         *   *  推荐阅读

## 剑指 Offer 06. 从尾到头打印链表 ##

[剑指 Offer 06. 从尾到头打印链表][Offer 06.]

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = \[1,3,2\]  
输出：\[2,3,1\]

限制：

0 <= 链表长度 <= 10000

### 利用栈 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public int[] reversePrint(ListNode head) {
        
            Deque<Integer> stack = new LinkedList<>();
            while (head != null) {
        
                stack.offerFirst(head.val);
                head = head.next;
            }
            int size = stack.size();
            int[] res = new int[size];
            int index = 0;
            while (!stack.isEmpty()) {
        
                res[index++] = stack.pollFirst();
            }
            return res;
        }
    }

### 逆向输入数组 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public int[] reversePrint(ListNode head) {
        
            ListNode curHead = head;
            int size = 0;
            while (curHead != null) {
        
                curHead = curHead.next;
                size++;
            }
            int[] res = new int[size];
            for (int i = size - 1; i >=0; i--) {
        
                res[i] = head.val;
                head = head.next;
            }
            return res;
        }
    }

## 剑指 Offer 24. 反转链表 ##

[剑指 Offer 24. 反转链表][Offer 24.]

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:
    
    输入: 1->2->3->4->5->NULL
    输出: 5->4->3->2->1->NULL
     
    
    限制：
    
    0 <= 节点个数 <= 5000

### 迭代解法 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode reverseList(ListNode head) {
        
            if (head == null || head.next == null) {
        
                return head;
            }
            ListNode newHead = new ListNode(-1);
            while (head != null) {
        
                ListNode next = head.next;
                head.next = newHead.next;
                newHead.next = head;
                head = next;
            }
            return newHead.next;
        }
    }

### 递归解法 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode reverseList(ListNode head) {
        
            if (head == null || head.next == null) {
        
                return head;
            }
            ListNode res = reverseList(head.next);
            head.next.next = head;
            head.next = null;
            return res;
        }
    }

## 剑指 Offer 18. 删除链表的节点 ##

[剑指 Offer 18. 删除链表的节点][Offer 18.]

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

注意：此题对比原题有改动

示例 1:
    
    输入: head = [4,5,1,9], val = 5
    输出: [4,1,9]
    解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
    示例 2:
    
    输入: head = [4,5,1,9], val = 1
    输出: [4,5,9]
    解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
     
    
    说明：
    
    题目保证链表中节点的值互不相同
    若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点

### 解法 ###

用前一个节点进行比较，可以直接删除节点。还可以用一个哑巴节点做头结点，这样就不用单独判断第一个节点了。

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode deleteNode(ListNode head, int val) {
        
            ListNode pre = head;
            if (head.val == val) {
        
                pre = head.next;
                head.next = null;
                return pre;
            }
            while (pre.next != null) {
        
                if (pre.next.val == val) {
        
                    pre.next = pre.next.next;
                    return head;
                }
                pre = pre.next;
            }
            return null;
        }
    }

## 删除排序链表中的重复元素 ##

[83. 删除排序链表中的重复元素][83.]

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2  
输出: 1->2  
示例 2:

输入: 1->1->2->3->3  
输出: 1->2->3

### 解法1 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode deleteDuplicates(ListNode head) {
        
            if (head == null) {
        
                return null;
            }
            ListNode prev = head, prevHead = prev;
            head = head.next;
            while (head != null) {
        
                if (prev.val != head.val) {
        
                    prev.next = head;
                    prev = prev.next;
                } else {
        
                    prev.next = null;
                }
                head = head.next;
            }
            return prevHead;
        }
    }

### 解法2 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode deleteDuplicates(ListNode head) {
        
            ListNode current = head;
            while (current != null && current.next != null) {
        
                if (current.val == current.next.val) {
        
                    current.next = current.next.next;
                } else {
        
                    current = current.next;
                }
            }
            return head;
        }
    }

### 递归 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode deleteDuplicates(ListNode head) {
        
            if (head == null || head.next == null) {
        
                return head;
            }
            head.next = deleteDuplicates(head.next);
            return head.val == head.next.val ? head.next : head;
        }
    }

## 删除链表的倒数第N个节点 ##

[19. 删除链表的倒数第N个节点][19. _N]

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.  
说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

### 解法 ###

快慢指针

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode removeNthFromEnd(ListNode head, int n) {
        
            ListNode fast = head;
            while (n-- > 0) {
        
                fast = fast.next;
            }
            if (fast == null) {
        
                return head.next;
            }
            ListNode slow = head;
            while(fast.next != null) {
        
                fast = fast.next;
                slow = slow.next;
            }
            slow.next = slow.next.next;
            return head;
        }
    }

## 剑指 Offer 22. 链表中倒数第k个节点 ##

[剑指 Offer 22. 链表中倒数第k个节点][Offer 22. _k]

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

### 快慢指针 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode getKthFromEnd(ListNode head, int k) {
        
            ListNode fast = head, slow = head;
            while (k-- > 0) {
        
                fast = fast.next;
            }
            while (fast != null) {
        
                fast = fast.next;
                slow = slow.next;
            }
            return slow;
        }
    }

## 剑指 Offer 35. 复杂链表的复制 ##

[剑指 Offer 35. 复杂链表的复制][Offer 35.]

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

示例 1：  
![format_png][]

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
    输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：  
![format_png 1][]

输入：head = [[1,1],[2,1]]
    输出：[[1,1],[2,1]]

示例 3：  
![format_png 2][]

输入：head = [[3,null],[3,0],[3,null]]
    输出：[[3,null],[3,0],[3,null]]
    示例 4：
    
    输入：head = []
    输出：[]
    解释：给定的链表为空（空指针），因此返回 null。
     
    
    提示：
    
    -10000 <= Node.val <= 10000
    Node.random 为空（null）或指向链表中的节点。
    节点数目不超过 1000 。

### 解法 ###

/*
    // Definition for a Node.
    class Node {
        int val;
        Node next;
        Node random;
    
        public Node(int val) {
            this.val = val;
            this.next = null;
            this.random = null;
        }
    }
    */
    
    class Solution {
        
        public Node copyRandomList(Node head) {
        
            if (head == null) {
        
                return null;
            }
            Node ptr = head;
            // 将原链表每个节点旁边增加一个节点
            while (ptr != null) {
        
                Node newNode = new Node(ptr.val);
                newNode.next = ptr.next;
                ptr.next = newNode;
                ptr = newNode.next;
            }
            ptr = head;
            // 将复制链表的random指向对应的位置
            while (ptr != null) {
        
                ptr.next.random = (ptr.random != null) ? ptr.random.next : null;
                ptr = ptr.next.next;
            }
            // 将复制链表的next指向对应的位置
            Node ptrOld = head, ptrNew = head.next, newHead = head.next;
            while (ptrOld != null) {
        
                ptrOld.next = ptrOld.next.next;
                ptrNew.next = (ptrNew.next != null) ? ptrNew.next.next : null;
                ptrOld = ptrOld.next;
                ptrNew = ptrNew.next;
            }
            return newHead;
        }
    }

## 剑指 Offer 52. 两个链表的第一个公共节点 ##

[剑指 Offer 52. 两个链表的第一个公共节点][Offer 52.]

输入两个链表，找出它们的第一个公共节点。

如下面的两个链表：  
![format_png 3][]  
在节点 c1 开始相交。

示例 1：

![format_png 4][]

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
    输出：Reference of the node with value = 8
    输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：  
![format_png 5][]

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
    输出：null
    输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
    解释：这两个链表不相交，因此返回 null。
    
    注意：
    
    如果两个链表没有交点，返回 null.
    在返回结果后，两个链表仍须保持原有的结构。
    可假定整个链表结构中没有循环。
    程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

### 解法 ###

A和B两个链表长度可能不同，但是A+B和B+A的长度是相同的，所以遍历A+B和遍历B+A一定是同时结束。 如果A,B相交的话A和B有一段尾巴是相同的，所以两个遍历的指针一定会同时到达交点 如果A,B不相交的话两个指针就会同时到达A+B（B+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 l1 = headA, l2 = headB;
            while (l1 != l2) {
        
                l1 = (l1 == null) ? headB : l1.next;
                l2 = (l2 == null) ? headA : l2.next;
            }
            return l1;
        }
    }

## 合并两个有序链表 ##

[21. 合并两个有序链表][21.]

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4  
输出：1->1->2->3->4->4

### 非递归解法 ###

每次找到最小结点，接在prev后面即可。

### 递归解法 ###

重复的子问题，递归可解。

## 两两交换链表中的节点 ##

[24. 两两交换链表中的节点][24.]

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:

![20201129124801.png][]

给定 1->2->3->4, 你应该返回 2->1->4->3.

### 解法 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode swapPairs(ListNode head) {
        
            ListNode newHead = new ListNode(-1);
            newHead.next = head;
            ListNode pre = newHead;
            while(pre.next != null && pre.next.next != null) {
        
                ListNode l1 = pre.next, l2 = pre.next.next;
                ListNode next = l2.next;
                l1.next = next;
                l2.next = l1;
                pre.next = l2;
                pre = l1;
            }
            return newHead.next;
        }
    }

## 两数相加 II ##

[445. 两数相加 II][445. _ II]

给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

进阶：

如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。

示例：

输入：(7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)  
输出：7 -> 8 -> 0 -> 7

### 解法 ###

将链表中的值存入栈，然后取出，头插法插入结果链表。

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        
            Deque<Integer> deque1 = buildDeque(l1);
            Deque<Integer> deque2 = buildDeque(l2);
            ListNode head = new ListNode(-1);
            int carry = 0;
            while (!deque1.isEmpty() || !deque2.isEmpty() || carry != 0) {
        
                int x = deque1.isEmpty() ? 0 : deque1.removeFirst();
                int y = deque2.isEmpty() ? 0 : deque2.removeFirst();
                int sum = x + y + carry;
                ListNode node = new ListNode(sum % 10);
                node.next = head.next;
                head.next = node;
                carry = sum / 10;
            }
            return head.next;
        }
        
        public Deque<Integer> buildDeque(ListNode node) {
         // 用deque模拟栈, 因为stack是遗留类，不推荐使用
            Deque<Integer> deque = new LinkedList<>();
            while (node != null) {
        
                deque.addFirst(node.val);
                node = node.next;
            }
            return deque;
        }
    }

## 回文链表 ##

[234. 回文链表][234.]

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2  
输出: false  
示例 2:

输入: 1->2->2->1  
输出: true  
进阶：  
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

### 解法 ###

切成两半，把后半段反转，然后比较两半是否相等。

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    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;
            }
            if (fast != null) {
        
                slow = slow.next;
            }
            cut(head, slow);
            return isEqual(head, reverse(slow));
        }
        private boolean isEqual(ListNode l1, ListNode l2) {
        
            while (l1 != null && l2 != null) {
        
                if (l1.val != l2.val) {
        
                    return false;
                }
                l1 = l1.next;
                l2 = l2.next;
            }
            return true;
        }
        private void cut(ListNode head, ListNode cutNode) {
        
            while (head.next != cutNode) {
        
                head = head.next;
            }
            head.next = null;
        }
        private ListNode reverse(ListNode head) {
        
            ListNode newHead = null;
            while (head != null) {
        
                ListNode nextNode = head.next;
                head.next = newHead;
                newHead = head;
                head = nextNode;
            }
            return newHead;
        } 
    }

### 解法2 ###

一样的思路

/**
     * 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 boolean isPalindrome(ListNode head) {
        
            if (head == null || head.next == null) {
        
                return true;
            }
            ListNode newHead = head;
            ListNode slow = head, fast = head.next;
            ListNode prev = head;
            // 找到中间点，并且记录中间点的上一个结点
            while (fast != null && fast.next != null) {
        
                prev = slow;
                slow = slow.next;
                fast = fast.next.next;
            }
            if (fast != null) {
        
                prev = prev.next;
                slow = slow.next;
            }
            // 截断链表
            prev.next = null;
            newHead = slow;
            // 对后一半链表翻转
            ListNode temp = new ListNode(-1);
            while (newHead != null) {
        
                ListNode next = newHead.next;
                newHead.next = temp.next;
                temp.next = newHead;
                newHead = next;
            }
            ListNode otherHead = temp.next;
            newHead = head;
            // 对比这两半链表是否相等。
            while (newHead != null && otherHead != null) {
        
                if (newHead.val != otherHead.val) {
        
                    return false;
                }
                newHead = newHead.next;
                otherHead = otherHead.next;
            }
            return true;
        }
    }

## 分隔链表 ##

[725. 分隔链表][725.]

给定一个头结点为 root 的链表, 编写一个函数以将链表分隔为 k 个连续的部分。

每部分的长度应该尽可能的相等: 任意两部分的长度差距不能超过 1，也就是说可能有些部分为 null。

这k个部分应该按照在链表中出现的顺序进行输出，并且排在前面的部分的长度应该大于或等于后面的长度。

返回一个符合上述规则的链表的列表。

举例： 1->2->3->4, k = 5 // 5 结果 \[ \[1\], \[2\], \[3\], \[4\], null \]

示例 1：

输入: 
    root = [1, 2, 3], k = 5
    输出: [[1],[2],[3],[],[]]
    解释:
    输入输出各部分都应该是链表，而不是数组。
    例如, 输入的结点 root 的 val= 1, root.next.val = 2, \root.next.next.val = 3, 且 root.next.next.next = null。
    第一个输出 output[0] 是 output[0].val = 1, output[0].next = null。
    最后一个元素 output[4] 为 null, 它代表了最后一个部分为空链表。
    示例 2：
    
    输入: 
    root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
    输出: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
    解释:
    输入被分成了几个连续的部分，并且每部分的长度相差不超过1.前面部分的长度大于等于后面部分的长度。
     
    
    提示:
    
    root 的长度范围： [0, 1000].
    输入的每个节点的大小范围：[0, 999].
    k 的取值范围： [1, 50].

### 解法 ###

/**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        
        public ListNode[] splitListToParts(ListNode root, int k) {
        
            int total = 0;
            ListNode cur = root;
            while (cur != null) {
        
                total++;
                cur = cur.next;
            }
            int mod = total % k;
            int size = total / k;
            cur = root;
            ListNode[] res = new ListNode[k];
            for (int i = 0; cur != null && i < k; ++i) {
        
                res[i] = cur;
                int curSize = size + (mod-- > 0 ? 1 : 0);
                for (int j = 0; j < curSize - 1; ++j) {
        
                    cur = cur.next;
                }
                ListNode temp = cur.next;
                cur.next = null;
                cur = temp;
            }
            return res;
        }
    }

## 奇偶链表 ##

[328. 奇偶链表][328.]

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。

示例 1:

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

输入: 2->1->3->5->6->4->7->NULL  
输出: 2->3->6->7->1->5->4->NULL  
说明:

应当保持奇数节点和偶数节点的相对顺序。  
链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。

### 解法1 ###

搞一个奇链表搞一个偶链表，最后链接在一块。

### 解法2 ###

一次走两步。

--------------------

#### 推荐阅读 ####

*  [机器学习资料汇总][Link 1]
 *  [吴恩达《机器学习》视频、作业、源码][Link 2]
 *  [106页《Python进阶》中文版正式发布][106_Python]
 *  [李航《统计学习方法》第二版完整课件][Link 3]
 *  [机器学习数学全书，1900页PDF下载][1900_PDF]

--------------------

![gzh.jpg][]

[Offer 06.]: https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/
[Offer 24.]: https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/
[Offer 18.]: https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/
[83.]: https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/
[19. _N]: https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
[Offer 22. _k]: https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/
[Offer 35.]: https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof/
[format_png]: /images/20221120/456324e512ce4378aad6f53eaf6e1ffe.png
[format_png 1]: /images/20221120/a41c8ac4f7534419b7e5fbf0b596a914.png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cDovL3dhcmRzZXB0ZW1iZXIudG9wLzIwMjAwNzIwMTk1ODA0LnBuZw?x-oss-process=image/format,png
[Offer 52.]: https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cDovL3dhcmRzZXB0ZW1iZXIudG9wLzIwMjAwNzIwMjAwNzMzLnBuZw?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cDovL3dhcmRzZXB0ZW1iZXIudG9wLzIwMjAwNzIwMjAwODA2LnBuZw?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cDovL3dhcmRzZXB0ZW1iZXIudG9wLzIwMjAwNzIwMjAwOTA5LnBuZw?x-oss-process=image/format,png
[21.]: https://leetcode-cn.com/problems/merge-two-sorted-lists/
[24.]: https://leetcode-cn.com/problems/swap-nodes-in-pairs/
[20201129124801.png]: https://gitee.com/wardseptember/images/raw/master/imgs/20201129124801.png
[445. _ II]: https://leetcode-cn.com/problems/add-two-numbers-ii/
[234.]: https://leetcode-cn.com/problems/palindrome-linked-list/
[725.]: https://leetcode-cn.com/problems/split-linked-list-in-parts/
[328.]: https://leetcode-cn.com/problems/odd-even-linked-list/
[Link 1]: https://mp.weixin.qq.com/s/3nOkk_Yt9D7Qp1WaWEjyZQ
[Link 2]: https://mp.weixin.qq.com/s/dErZNtBYbVA7ItPm7T_HIw
[106_Python]: https://mp.weixin.qq.com/s/_WEuuxj-QgihijjLz7NJ9g
[Link 3]: https://mp.weixin.qq.com/s/xah47OWuu8ahAUa1aFFo4Q
[1900_PDF]: https://mp.weixin.qq.com/s/9BuyhdwuHiHH3ksVUe44ZQ
[gzh.jpg]: https://gitee.com/wardseptember/images/raw/master/imgs/gzh.jpg