Newcoder Top 101 链表专题

牛客算法必刷TOP101，包含：链表、二分查找/排序、二叉树、堆/栈/队列、哈希、递归/回溯、动态规划、字符串、双指针、贪心算法、模拟总共101道题。

此部分是链表专题。

牛客网 (nowcoder.com)

反转链表

描述

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤1000

要求：空间复杂度 O*(1) ，时间复杂度 O*(*n) 。

如当输入链表{1,2,3}时，

经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

以上转换过程如下图所示：

示例1

输入：

1{1,2,3}

返回值：

1{3,2,1}

示例2

输入：

1{}

返回值：

1{}

说明：

1空链表则输出空

解法

原地置换

分别用三个指针pre,cur,next代表之前的结点，当前的结点，下一个结点。改变链表的指向关系就可以原地改变顺序。

以下是模拟的过程

代码如下：

 1class Solution {
 2public:
 3    ListNode* ReverseList(ListNode* pHead) {
 4        ListNode*pre = nullptr;
 5        ListNode*cur = pHead;
 6        while(cur){
 7            ListNode*next = cur->next; // 第四步
 8            cur->next = pre; //第一步
 9            pre = cur; //第二步
10            cur = next; // 第三步
11        }
12        return pre;
13    }
14};

链表内指定区间反转

描述

将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。例如：给出的链表为 1→2→3→4→5→NULL, m*=2,*n=4, 返回 1→4→3→2→5→NULL

要求：时间复杂度 O(n)O(n) ，空间复杂度 O(n)O(n)

进阶：时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)

示例1

输入：

1{1,2,3,4,5},2,4

返回值：

1{1,4,3,2,5}

示例2

输入：

1{5},1,1

返回值：

1{5}

解析

解法一

对于这道题，我们可以参考反转链表的题，只需要直到指定的区间的链表，然后断开，将这个区间的链表进行反转。

注意，由于在此过程中需要保存区间左边和右边的链表，所以需要加上一个新的头结点来处理边界问题。

 1// 反转当前链表
 2ListNode *reverse(ListNode *head) {
 3    ListNode *pre = nullptr;
 4    ListNode *cur = head;
 5    ListNode *next = nullptr;
 6    while (cur) {
 7        next = cur->next;
 8        cur->
 9                next = pre;
10        pre = cur;
11        cur = next;
12    }
13    return pre;
14}
15
16
17ListNode *reverseBetween(ListNode *head, int m, int n) {
18    if (head->next == nullptr || head == nullptr || m == n) {
19        return
20                head;
21    }
22    // 防止出现pre的问题
23    auto *newHead = new ListNode(0);
24    newHead->next = head;
25    ListNode *pre = newHead;
26    // 从哪里开始的
27    ListNode *begin = head;
28    // 结束的最后一个结点
29    ListNode *end = nullptr;
30    // 结束断开的下一个
31    ListNode *endEnd = nullptr;
32    // 找到从哪里开始断开
33    for (int i = 0; i < m - 1; i++) {
34        pre = begin;
35        begin = begin->next;
36    }
37    // 断开左边的
38    pre->next = nullptr;
39
40    // 从哪里结束
41    end = begin;
42    for (int i = m; i < n; i++) {
43        end = end->next;
44    }
45    // 右边断开的
46    endEnd = end->next;
47    // 断开
48    end->next = nullptr;
49    // 反转区间的链表
50    end = reverse(begin);
51    // 反转之后接上， 区间头变成尾，尾巴变成了头
52    pre->next = end;
53    begin->next = endEnd;
54    return newHead->next;
55}

解法二

利用头插法将新遍历的结点放到前面来。

将cur的next指向next的next
next的next指向pre的next
pre的next指向next。

 1ListNode *reverseBetween(ListNode *head, int m, int n) {
 2    // 防止出现pre的问题
 3    auto *newHead = new ListNode(0);
 4    newHead->next = head;
 5    ListNode *pre = newHead;	
 6    for(int i = 1;i<m;i++){
 7        pre = pre->next;
 8    }
 9    cur = pre->next;
10    for(int i = m;i<n;i++){
11        ListNode*next = cur->next;
12        cur->next= next->next;
13        next->next= pre->next;
14        pre->next= next;
15    }
16    return newHead->next;
17}

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

描述

将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样你不能更改节点中的值，只能更改节点本身。

数据范围： 0≤n≤2000 ， 1≤k≤2000 ，链表中每个元素都满足 0≤val≤1000 要求空间复杂度 O(1)，时间复杂度 O(n)

例如：

给定的链表是 1→2→3→4→5

对于 k=2 , 你应该返回 2→1→4→3→5

对于 k=3 , 你应该返回 3→2→1→4→5

示例1

输入：

1{1,2,3,4,5},2

复制

返回值：

1{2,1,4,3,5}

复制

示例2

输入：

1{},1

复制

返回值：

1{}

解析

通过链表指定区间的反转我们知道了利用头插法进行转换链表，这个题也是类似。都反转，对每一组都是指定区间的反转。只需要将k个结点分为一组就行。

 1    ListNode* reverseKGroup(ListNode* head, int k) {
 2        int len = 0;
 3        ListNode*cur = head;
 4        ListNode*newHead = new ListNode(0);
 5        newHead->next = head;
 6        // 求出总共有多长
 7        while(cur){
 8            len++;
 9            cur = cur->next;
10        }
11        ListNode *pre = newHead;
12        cur = head;
13        // 分成多少组
14        for(int i = 0;i<len/k;i++){
15            // 组内进行区间反转
16            for(int j = 1;j<k;j++){
17                ListNode*next = cur->next;
18                cur->next=next->next;
19                next->next= pre->next;
20                pre->next= next;
21            }
22            pre = cur;
23            cur = cur->next;
24        }
25        return newHead->next;
26    }

合并两个排序的链表

描述

输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}

示例1

输入：

1{1,3,5},{2,4,6}

返回值：

1{1,2,3,4,5,6}

复制

示例2

输入：

1{},{}

返回值：

1{}

示例3

输入：

1{-1,2,4},{1,3,4}

返回值：

1{-1,1,2,3,4,4}

解析

解法一

利用归并排序的思想，进行模拟即可。

 1ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
 2    ListNode *res = new ListNode(0);
 3    ListNode *cur = res;
 4    while(pHead1&&pHead2){
 5        if(pHead1->val<=pHead2->val){
 6            cur->next = pHead1;
 7            pHead1 = pHead1->next;
 8        }else{
 9            cur->next = pHead2;
10            pHead2 = pHead2->next;
11      	}
12        cur = cur->next;
13    }
14    if(pHead1){
15        cur->next = pHead1;
16    }
17    if(pHead2){
18        cur->next = pHead2;
19    }
20    return res->next;
21}

解法二

我们利用归并思想不断合并两个链表，每当我们添加完一个节点后，该节点指针后移，相当于这个链表剩余部分与另一个链表剩余部分合并，两个链表剩余部分合并就是原问题两个有序链表合并的子问题，因此也可以使用递归：

终止条件： 当一个链表已经因为递归到了末尾，另一个链表剩余部分一定都大于前面的，因此我们可以将另一个链表剩余部分拼在结果后面，结束递归。
返回值： 每次返回拼接好的较大部分的子链表。
本级任务： 每级不断进入下一个较小的值后的链表部分与另一个链表剩余部分，再将本次的节点接在后面较大值拼好的结果前面。

具体做法：

step 1：每次比较两个链表当前节点的值，然后取较小值的链表指针往后，另一个不变，两段子链表作为新的链表送入递归中。
step 2：递归回来的结果我们要加在当前较小值的节点后面，相当于不断在较小值后面添加节点。
step 3：递归的终止是两个链表有一个为空。

 1// 每次返回拼接好的较大部分的子链表
 2ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
 3    //一个已经为空了，返回另一个
 4    if(pHead1==nullptr){
 5        return pHead2;
 6    }
 7    if(pHead2==nullptr){
 8        return pHead1;
 9    }
10
11    if(pHead1->val<=pHead2->val){
12        pHead1->next = Merge(pHead1->next, pHead2);
13        return pHead1;
14    }else{
15        pHead2->next = Merge(pHead1, pHead2->next);
16        return pHead2;
17    }
18}

合并k个已排序的链表

描述

合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。

数据范围：节点总数满足 0≤n≤105，链表个数满足 1≤k≤10^5 ，每个链表的长度满足 1≤len≤200 ，每个节点的值满足 |val| <= 1000

要求：时间复杂度 O(nlogk)

示例1

输入：

1[{1,2,3},{4,5,6,7}]

返回值：

1{1,2,3,4,5,6,7}

示例2

输入：

1[{1,2},{1,4,5},{6}]

返回值：

1{1,1,2,4,5,6}

解析

解析1-超时

上面已经完成了两个排序链表的合并,两个链表两两进行合并就行。但是时间复杂度是O(n*k)不满足时间要求。

 1    ListNode*merge(ListNode*list1,ListNode*list2){
 2        ListNode * res = new ListNode(0);
 3        ListNode *cur = res;
 4        while(list1&&list2){
 5            if(list1->val<=list2->val){
 6                cur->next = list1;
 7                list1 = list1->next;
 8            }else{
 9                cur->next = list2;
10                list2 = list2->next;
11            }
12            cur =cur->next;
13        }
14        if(list1){
15            cur->next = list1;
16        }
17        if(list2){
18            cur->next = list2;
19        }
20        return res->next;
21    }
22    ListNode *mergeKLists(vector<ListNode *> &lists) {
23        ListNode *res ;
24        for(int i = 0;i<lists.size();i++){
25            res = merge(res, lists[i]);
26        }
27        return res;
28    }

解析2

上述中，我们是让合并好的再和新的进行合并，其实我们可以让新的链表两两合并，减少额外的合并次数。降低时间复杂度。

 1   ListNode*merge(ListNode*list1,ListNode*list2){
 2        ListNode * res = new ListNode(0);
 3        ListNode *cur = res;
 4        while(list1&&list2){
 5            if(list1->val<=list2->val){
 6                cur->next = list1;
 7                list1 = list1->next;
 8            }else{
 9                cur->next = list2;
10                list2 = list2->next;
11            }
12            cur =cur->next;
13        }
14        if(list1){
15            cur->next = list1;
16        }
17        if(list2){
18            cur->next = list2;
19        }
20        return res->next;
21    }
22    
23    // 分组进行合并
24    ListNode* groupMerge(vector<ListNode *> &lists,int left,int right){
25        // 中间只有一个的情况
26        if(left==right){
27            return lists[left];
28        }
29        if(left>right){
30            return nullptr;
31        }
32        // 从中间分开两段，分开的部分进行合并
33        int mid = (left+right)>>1;
34        // 合并的两部分再进行合并
35        return merge(groupMerge(lists, left, mid), groupMerge(lists, mid+1, right));
36        
37    }
38    ListNode *mergeKLists(vector<ListNode *> &lists) {
39        return groupMerge(lists, 0, lists.size()-1);
40    }

判断链表中是否有环

描述

判断给定的链表中是否有环。如果有环则返回true，否则返回false。

数据范围：链表长度 0≤n≤10000，链表中任意节点的值满足 |val| <= 100000

要求：空间复杂度 O(1),时间复杂度 O(n)

输入分为两部分，第一部分为链表，第二部分代表是否有环，然后将组成的head头结点传入到函数里面。-1代表无环，其它的数字代表有环，这些参数解释仅仅是为了方便读者自测调试。实际在编程时读入的是链表的头节点。

例如输入{3,2,0,-4},1时，对应的链表结构如下图所示：

可以看出环的入口结点为从头结点开始的第1个结点（注：头结点为第0个结点），所以输出true。

示例1

输入：

1{3,2,0,-4},1

返回值：

1true

说明：

1第一部分{3,2,0,-4}代表一个链表，第二部分的1表示，-4到位置1（注：头结点为位置0），即-4->2存在一个链接，组成传入的head为一个带环的链表，返回true

示例2

输入：

1{1},-1

返回值：

1false

说明：

1第一部分{1}代表一个链表，-1代表无环，组成传入head为一个无环的单链表，返回false

示例3

输入：

1{-1,-7,7,-4,19,6,-9,-5,-2,-5},6

返回值：

1true

解析

方法1-哈希表

将已经遍历过的结点保存在map中，如果map中已经有了，就说明有环，整个链表遍历完之后都没有，就说明没有环。

 1bool hasCycle(ListNode* head) {
 2        map<ListNode*, bool> m;
 3        while (head) {
 4            auto a = m.find(head);
 5            if (a != m.end()) {
 6                return true;
 7            } else {
 8                m[head] = true;
 9            }
10            head = head->next;
11        }
12    return false;
13}

方法2-双指针

一个快指针走两步，一个慢指针走一步。当两个指针相遇的时候就说明，是有环的。证明过程如下：

「代码随想录」你的疑惑，这里都讲清楚了！142. 环形链表 II - 环形链表 II - 力扣（LeetCode） (leetcode-cn.com)

 1bool hasCycle(ListNode* head) {
 2        ListNode* fast = head;
 3        ListNode* slow = head;
 4        while (fast && fast->next) {
 5            fast = fast->next->next;
 6            slow = slow->next;
 7            if (fast == slow) {
 8                return true;
 9            }
10        }
11        return false;
12}

链表中环的入口结点

给一个长度为n链表，若其中包含环，请找出该链表的环的入口结点，否则，返回null。

数据范围：n*≤10000，1<=结点值<=10000

要求：空间复杂度 O(1)，时间复杂度 O(n)

例如，输入{1,2},{3,4,5}时，对应的环形链表如下图所示：

可以看到环的入口结点的结点值为3，所以返回结点值为3的结点。

输入描述：

输入分为2段，第一段是入环前的链表部分，第二段是链表环的部分，后台会根据第二段是否为空将这两段组装成一个无环或者有环单链表

返回值描述：

返回链表的环的入口结点即可，我们后台程序会打印这个结点对应的结点值；若没有，则返回对应编程语言的空结点即可。

示例1

输入：

1{1,2},{3,4,5}

返回值：

说明：

1返回环形链表入口结点，我们后台程序会打印该环形链表入口结点对应的结点值，即3

示例2

输入：

1{1},{}

返回值：

1"null"

说明：

1没有环，返回对应编程语言的空结点，后台程序会打印"null"

示例3

输入：

1{},{2}

返回值：

说明：

1环的部分只有一个结点，所以返回该环形链表入口结点，后台程序打印该结点对应的结点值，即2

解析

解析1-哈希表

和判断链表中是否有环是一样的，如果map中有就说明这个位置就是环，否则就是没有环。

 1ListNode* EntryNodeOfLoop(ListNode* head) {
 2        map<ListNode*, bool> m;
 3        while (head) {
 4            auto a = m.find(head);
 5            if (a != m.end()) {
 6                return a.first;
 7            } else {
 8                m[head] = true;
 9            }
10            head = head->next;
11        }
12    return nullptr;
13}

解析2-双指针

一个快指针走两步，一个慢指针走一步。当两个指针相遇的时候就说明，是有环的。有环之后，让头指针和相遇的指针一起走，相遇之后就是环的入口：

「代码随想录」你的疑惑，这里都讲清楚了！142. 环形链表 II - 环形链表 II - 力扣（LeetCode） (leetcode-cn.com)

 1ListNode* EntryNodeOfLoop(ListNode* pHead) {
 2        ListNode* fast = pHead;
 3        ListNode* slow = pHead;
 4        while (fast && fast->next) {
 5            fast = fast->next->next;
 6            slow = slow->next;
 7            if (fast == slow) {
 8                while(fast!=pHead){
 9                    fast  = fast->next;
10                    pHead = pHead->next;
11                }
12                return fast;
13            }
14        }
15        return nullptr;
16    }

链表中倒数最后k个结点

描述

输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。

如果该链表长度小于k，请返回一个长度为 0 的链表。

数据范围：$0 \leq n \leq 10^50≤n≤105$，$0 \leq a_i \leq 10^9$，$0 \leq k \leq 10^9$

要求：空间复杂度 O(n)，时间复杂度 O(n)

进阶：空间复杂度 O(1)，时间复杂度 O(n)

例如输入{1,2,3,4,5},2时，对应的链表结构如下图所示：

其中蓝色部分为该链表的最后2个结点，所以返回倒数第2个结点（也即结点值为4的结点）即可，系统会打印后面所有的节点来比较。

示例1

输入：

1{1,2,3,4,5},2

返回值：

1{4,5}

说明：

1返回倒数第2个节点4，系统会打印后面所有的节点来比较。

示例2

输入：

1{2},8

返回值：

1{}

解析

解法1-数组

将链表的每一个结点按照顺序保存到数组中，按照要求求出当前倒数第几个结点。

解法2-遍历两遍

第一遍求出链表的长度，第二遍遍历到倒数第k个结点。

 1ListNode* FindKthToTail(ListNode* pHead, int k) {
 2        int len = 0;
 3        ListNode* cur = pHead;
 4        // 求长度
 5        while (cur) {
 6            len++;
 7            cur = cur->next;
 8        }
 9        // 指向头
10        cur = pHead;
11        // 如果超过长度了，返回空
12        if (k > len) {
13            return nullptr;
14        }
15        len -= k;
16        while (len > 0) {
17            cur = cur->next;
18            len--;
19        }
20        return cur;
21    }

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

描述

给定一个链表，删除链表的倒数第 n 个节点并返回链表的头指针.

例如，给出的链表为: $1\to 2\to 3\to 4\to 5$, n= 2,删除了链表的倒数第 n 个节点之后,链表变为$1\to 2\to 3\to 5$。

数据范围：链表长度 $0\le n \le 1000$，链表中任意节点的值满足 $0 \le val \le 100$

要求：空间复杂度 $O(1)$，时间复杂度 $O(n)$

题目保证 $n$一定是有效的

示例1

输入：

1{1,2},2

返回值：

1{2}

解析

解析1-求长度，找到倒数第n+1个结点

利用链表中倒数第k个结点可以找到倒数第n+1个结点，根据倒数第$n+1$个结点，使用$cur\to next = cur\to next\to next$删除倒数第n个结点。

 1ListNode* removeNthFromEnd(ListNode* head, int n) {
 2    ListNode *newHead = new ListNode(0);
 3    newHead->next = head;
 4    // 找到倒数第n+1个元素
 5    int len = 0;
 6    ListNode *cur = newHead;
 7    while(cur){
 8        len++;
 9        cur = cur->next;
10    }
11    cur = newHead;
12   	// 这里的n+2是因为添加了一个新的头结点。
13    len-=n+2;
14    while(len>-1){
15        cur = cur->next;
16        len--;
17    }
18        
19    cur->next = cur->next->next;
20    return newHead->next;
21}

解析2-双指针

快指针指向head,快指针先走n步。慢指针指向新的头结点，当快指针走完n步之后，慢指针跟着快指针走完全部的。这时候慢指针指向的是倒数第n+1个结点，然后利用$cur\to next = cur\to next\to next$删除倒数第n个结点。

重要！！！！

快指针指向head,快指针先走n步
慢指针指向newHead,跟随快指针走，等到快指针走完，这时候，慢指针就在倒数第n+1个结点。

 1ListNode* removeNthFromEnd(ListNode* head, int n) {
 2    ListNode *newHead = new ListNode(0);
 3    newHead->next = head;
 4    // 快指针指向head
 5    ListNode*fast = head;
 6    // 慢指针指向newHead
 7    ListNode*slow = newHead;
 8    // 快指针先走n步
 9    while(n>0){
10        n--;
11        fast = fast->next;
12    }
13    // 快指针走完全部
14    while(fast){
15        fast = fast->next;
16        slow = slow->next;
17    }
18    // 慢指针在倒数第n+1个结点
19    slow->next = slow->next->next;
20    return newHead->next;
21}

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

描述

输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

数据范围： $n \le 1000$ 要求：空间复杂度 O(1)O(1)，时间复杂度 $O(n)$

例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：

可以看到它们的第一个公共结点的结点值为6，所以返回结点值为6的结点。

输入描述：

输入分为是3段，第一段是第一个链表的非公共部分，第二段是第二个链表的非公共部分，第三段是第一个链表和第二个链表的公共部分。后台会将这3个参数组装为两个链表，并将这两个链表对应的头节点传入到函数FindFirstCommonNode里面，用户得到的输入只有pHead1和pHead2。

返回值描述：

返回传入的pHead1和pHead2的第一个公共结点，后台会打印以该节点为头节点的链表。

示例1

输入：

1{1,2,3},{4,5},{6,7}

返回值：

1{6,7}

说明：

1第一个参数{1,2,3}代表是第一个链表非公共部分，第二个参数{4,5}代表是第二个链表非公共部分，最后的{6,7}表示的是2个链表的公共部分
2这3个参数最后在后台会组装成为2个两个无环的单链表，且是有公共节点的

示例2

输入：

1{1},{2,3},{}

返回值：

1{}

说明：

12个链表没有公共节点 ,返回null，后台打印{}

解析

解析1-求长度，从最短的进行比较。

求出两个链表的长度，找出最短的一个链表，较长的链表遍历到和较短的链表长度一样，进行比较链表。

注意：

比较的是链表指针，不是值。

 1ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
 2        int len1 = 0;
 3        int len2 = 0;
 4        ListNode*cur = pHead1;
 5    	// 求链表1的长度
 6        while(cur){
 7            len1++;
 8            cur = cur->next;
 9        }
10    	// 求链表二的长度
11        cur = pHead2;
12        while(cur){
13            len2++;
14            cur=cur->next;
15        }
16        // 找出长的一个，遍历到和短的一样。
17        if(len1>len2){
18            len1-=len2;
19            while(len1>0){
20                pHead1=pHead1->next;
21                len1--;
22            }
23        }else{
24            len2-=len1;
25            while(len2>0){
26                pHead2 = pHead2->next;
27                len2--;
28            }
29        }
30    	// 两个进行比较
31        while(pHead1){
32            if(pHead1==pHead2){
33                return pHead1;
34            }
35            pHead1 = pHead1->next;
36            pHead2 = pHead2->next;
37        }
38        return nullptr;
39    }

解析2-遍历两次结点

使用两个指针N1,N2，一个从链表1的头节点开始遍历，我们记为N1，一个从链表2的头节点开始遍历，我们记为N2。

让N1和N2一起遍历，当N1先走完链表1的尽头（为null）的时候，则从链表2的头节点继续遍历，同样，如果N2先走完了链表2的尽头，则从链表1的头节点继续遍历，也就是说，N1和N2都会遍历链表1和链表2。

因为两个指针，同样的速度，走完同样长度（链表1+链表2），不管两条链表有无相同节点，都能够到达同时到达终点。

（N1最后肯定能到达链表2的终点，N2肯定能到达链表1的终点）。

所以，如何得到公共节点：

有公共节点的时候，N1和N2必会相遇，因为长度一样嘛，速度也一定，必会走到相同的地方的，所以当两者相等的时候，则会第一个公共的节点
无公共节点的时候，此时N1和N2则都会走到终点，那么他们此时都是null，所以也算是相等了

题解 | #两个链表的第一个公共结点#_牛客博客 (nowcoder.net)

 1ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
 2    ListNode*n1 = pHead1;
 3    ListNode*n2 = pHead2;
 4    while(n1!=n2){
 5        if(!n1){
 6            n1 = pHead2;
 7        }else{
 8            n1 = n1->next;
 9        }
10            
11        if(!n2){
12            n2 = pHead1;
13        }else{
14            n2 = n2->next;
15        }
16    }
17    return n1;     
18    }

链表相加(二)

描述

假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。

给定两个这种链表，请生成代表两个整数相加值的结果链表。

数据范围：$0 \le n,m \le 1000000$，链表任意值要求：空间复杂度 $O(n)$，时间复杂度 $O(n)$

例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

示例1

输入：

1[9,3,7],[6,3]

返回值：

1{1,0,0,0}

说明：

1如题面解释

示例2

输入：

1[0],[6,3]

返回值：

1{6,3}

解析

解析1-链表反转求和

由于所给的链表的头结点是最高位，而我们运算是从最低位开始相加，在运算之前先将链表反转为从低位开始。

对于求和可以正常的模拟加法求和就可以。

注意

逢十进一
如果有进位要相加
最后有进位要额外新建结点。

 1ListNode*reverse(ListNode*list){
 2    ListNode*pre = nullptr;
 3    ListNode*cur = list;
 4    while(cur){
 5        ListNode*next = cur->next;
 6        cur->next = pre;
 7        pre = cur;
 8        cur = next;
 9    }
10    return pre;
11}
12ListNode* addInList(ListNode* head1, ListNode* head2){
13    int add = 0;
14    head1 = reverse(head1);
15    head2 = reverse(head2);
16    ListNode *pre = nullptr;
17    while(add||head1||head2){
18        int val = add;
19        if(head1){
20            val+=head1->val;
21            head1=head1->next;
22        }
23        if(head2){
24            val+=head2->val;
25            head2 =head2->next;
26        }
27        add = val/10;
28        val = val%10;
29        ListNode*cur = new ListNode(val);
30        cur->next = pre;
31        pre = cur;
32    }
33    return pre;
34}

解析2-栈实现反转链表

与方法一相同，只不过反转链表的时候是用了栈。

单链表的排序

描述

给定一个节点数为n的无序单链表，对其按升序排序。

数据范围：$0 < n \le 100000$

要求：时间复杂度 $O(nlogn)$

示例1

输入：

1{1,3,2,4,5}

返回值：

1{1,2,3,4,5}

解析

解析1-归并排序

 1 //合并两段有序链表
 2    ListNode* merge(ListNode* pHead1, ListNode* pHead2) {
 3        if(pHead1 == NULL)
 4            return pHead2;
 5        if(pHead2 == NULL)
 6            return pHead1;
 7        ListNode* head = new ListNode(0);
 8        ListNode* cur = head;
 9        while(pHead1 && pHead2){
10            if(pHead1->val <= pHead2->val){
11                cur->next = pHead1;
12                pHead1 = pHead1->next;
13            }else{
14                cur->next = pHead2;
15                pHead2 = pHead2->next;
16            }
17            cur = cur->next;
18        }
19        if(pHead1)
20            cur->next = pHead1;
21        else
22            cur->next = pHead2;
23        return head->next;
24    }
25
26	// 归并排序递归版
27    ListNode* sortInList(ListNode* head) {
28        if(head==nullptr||head->next==nullptr){
29            return head;
30        }
31        // 中间结点的前一个，整个链表要断开
32        ListNode*midPre = head;
33        ListNode*mid  = head->next;
34        ListNode*right = head->next->next;
35        while(right&&right->next){
36            midPre = midPre->next;
37            mid = mid->next;
38            right = right->next->next;
39        }
40        // 断开链表
41        midPre->next = nullptr;
42        // 归并排序的左边和右边。
43        return merge(sortInList(head),sortInList(mid));
44        
45    }

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

描述

给定一个链表，请判断该链表是否为回文结构。

回文是指该字符串正序逆序完全一致。

数据范围：链表节点数 0 \le n \le 10^50≤n≤105，链表中每个节点的值满足 |val| \le 10^7∣val∣≤107

示例1

输入：

1{1}

返回值：

1true

示例2

输入：

1{2,1}

返回值：

1false

说明：

12->1

示例3

输入：

1{1,2,2,1}

返回值：

1true

说明：

11->2->2->1

解析

解析1-反转链表进行比较

从中间将整个链表一分为二，对右边进行反转，反转过来的链表在与之前的链表进行比较。

注意

区分链表结点个数是奇数还是偶数，如果是奇数，应该把多的一部分的结点放在左边，例如是1->2->4->2->3,分开的链表应该是1->2->4和2->3,然后将右边的进行反转。只要将结点少的进行反转就可以

 1// 链表反转
 2ListNode*reverse(ListNode*list){
 3        ListNode*pre = nullptr;
 4        ListNode*cur = list;
 5        ListNode*next = nullptr;
 6        while(cur){
 7            next = cur->next;
 8            cur->next = pre;
 9            pre = cur;
10            cur = next;
11        }
12        return pre;
13    }
14    /**
15     * 
16     * @param head ListNode类 the head
17     * @return bool布尔型
18     */
19    bool isPail(ListNode* head) {
20        // 如果只有一个结点，肯定是回文的。
21        if(head->next==nullptr){
22            return true;
23        }
24        ListNode*midPre = head;
25        ListNode*mid = head->next;
26        ListNode*right =mid->next;
27        // 找到中间的结点
28        while(right&&right->next){
29            midPre = midPre->next;
30            mid = mid->next;
31            right = right->next->next;
32        }
33        // 断开中间的结点
34        midPre->next = nullptr;
35        // 反转结点少的链表
36        mid = reverse(mid);
37        // 判断
38        while(head&&mid){
39            if(head->val!=mid->val){
40                return false;
41            }
42            head = head->next;
43            mid = mid->next;
44        }
45        return true;
46    }

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

描述

删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次例如：给出的链表为$1\to1\to2$,返回$1 \to 2$. 给出的链表为$1\to1\to 2 \to 3 \to 3$,返回$1\to 2 \to 3$.

数据范围：链表长度满足 $0 \le n \le 100$，链表中任意节点的值满足$ |val| \le 100$

进阶：空间复杂度 O(1)，时间复杂度 O(n)

示例1

输入：

1{1,1,2}

返回值：

1{1,2}

示例2

输入：

1{}

返回值：

1{}

解析

解析1-模拟

比较当前结点的值和之前结点的值是否一样，如果一样当前结点的next指向cur->next->next。否则指向cur->next。

 1ListNode* deleteDuplicates(ListNode* head) {
 2        ListNode*cur = head;
 3        while(cur&&cur->next){
 4            if(cur->val==cur->next->val){
 5                cur->next = cur->next->next;
 6            }else{
 7                cur = cur->next;
 8            }
 9        }
10        return head;
11    }

链表的奇偶重排

给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。

注意是节点的编号而非节点的数值。

数据范围：节点数量满足 $0 \le n \le 10^5$，节点中的值都满足 $0 \le val \le 1000$

要求：空间复杂度 O(n)，时间复杂度 O(n)

示例1

输入：

1{1,2,3,4,5,6}

返回值：

1{1,3,5,2,4,6}

说明：

11->2->3->4->5->6->NULL
2重排后为1->3->5->2->4->6->NULL
3

示例2

输入：

1{1,4,6,3,7}

返回值：

1{1,6,7,4,3}

说明：

11->4->6->3->7->NULL
2重排后为
31->6->7->4->3->NULL
4奇数位节点有1,6,7，偶数位节点有4,3。重排后为1,6,7,4,3

解析

解析1-分别保存奇偶指针

分别保存奇偶指针，奇指针指向head，偶指针指向head->next，奇偶指针每次向后移动两位就可以。

 1ListNode* oddEvenList(ListNode* head) {
 2    // 如果只有一或两个结点，就返回head
 3    if(head==nullptr||head->next==nullptr){
 4        return head;
 5    }
 6    // 开始奇数指针指向头
 7    ListNode*jishu = head;
 8    // 偶数指针要记录偶数的头结点，后面要连起来
 9    ListNode*oushuBegin = head->next;
10    // 每次更新的偶数结点
11    ListNode*oushuCur = oushuBegin;
12    // 偶数结点有
13    while(oushuCur&&oushuCur->next){
14        // 更新奇数结点
15        jishu->next = oushuCur->next;
16        jishu = jishu->next;
17        // 更新偶数结点，此时奇数结点指向的时上一个偶数结点的next
18        oushuCur->next = jishu -> next;
19        oushuCur = oushuCur->next;
20    }
21    // ji
22    jishu->next = oushuBegin;        
23    return head;
24}

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

描述

给出一个升序排序的链表，删除链表中的所有重复出现的元素，只保留原链表中只出现一次的元素。例如：给出的链表为$1 \to 2\to 3\to 3\to 4\to 4\to5$, 返回$1\to 2\to5$. 给出的链表为$1\to1 \to 1\to 2 \to 3$, 返回$2\to 3$.

数据范围：链表长度 $0 \le n \le 10000$，链表中的值满足 $|val| \le 1000$

要求：空间复杂度 O(n)，时间复杂度 O(n)

进阶：空间复杂度 O(1)，时间复杂度 O(n)

示例1

输入：

1{1,2,2}

返回值：

1{1}

示例2

输入：

1{}

返回值：

1{}

解析

解析一

一次判断两个结点，如果两个结点的值不一样，就向前探索。

如果这两个结点的值一样，那么就一直往下探索到下一个值得结点。

 1ListNode* deleteDuplicates(ListNode* head) {
 2    if(head==nullptr){
 3        return head;
 4    }
 5    ListNode *newHead = new ListNode(head->val-1);
 6    newHead->next = head;
 7    ListNode *cur = head;
 8    ListNode *pre =newHead;
 9    while(cur&&cur->next){
10        if(cur->val==cur->next->val){
11            int t = cur->val;
12            while(cur&&cur->val==t){
13                cur = cur->next;
14            }
15            pre->next = cur;
16        }else{
17            pre = cur;
18            cur=cur->next;
19        }
20    }
21    return newHead->next;
22}

总结

刷题时间

时间	题目
4-22	反转链表
4-22	链表指定区间反转
4-24	链表每k个结点反转
4-24	合并两个有序链表
4-25	合并k个有序链表
4-25	判断链表中有环
4-25	判断链表中环的入口
4-25	链表中倒数第k个结点
4-26	删除链表的倒数第n个结点
4-26	两个链表的第一个公共结点
4-26	链表相加
4-26	单链表排序
4-26	判断链表是否为回文链表
4-26	删除有序链表中的重复元素-Ⅰ
4-28	链表的奇偶重拍
4-28	删除有序链表中重复元素-Ⅱ

技巧总结

链表的题目首先要在纸上模拟好过程，对于结点的指向清楚之后写代码很清楚。
新的头结点很重要，可以帮助我们处理很多边界问题。
反转链表有两种高效的方法
1. 利用头插法反转，每次探索到的新结点都以头插法的方式放到头部。
2. 断开遍历的下一个结点
合并链表就是归并处理。
合并k个有序链表，链表两两进行合并，合并之后再合并。归并排序的思想
链表是否有环，如果有环，类似两个不同速度的人一起在环里跑步，一定会相遇。
判断环的入口，要涉及到数学证明
链表中的倒数第k个结点，最优的应该是快慢指针，让快指针先走k次，然后慢指针一起走完。同时删除也是类似。
链表相加，可以先将链表反转之后进行模拟
单链表排序，链表排序使用不了快排，只能用归并排序
判断是否是回文，反转后半部分链表与前半部分进行比较

重刷总结

// todo