LeetCode链表专题
链表
套路总结
1.多个指针 移动
2.虚假链表头：凡是有可能删除头节点的都创建一个虚拟头节点，代码可以少一些判断(需要用到首部前一个元素的时候就加虚拟头指针)
3.快慢指针
如leetcode142 快慢指针找链表环的起点
19. 删除链表的倒数第N个节点
题目要求：只扫描一遍
删除链表，肯定要找到被删节点的前一个节点
1.找到倒数第n个节点的前一个节点(倒数第n+1)
2.双指针
first指针指向第k个，second头指针指向虚假头节点，两个指针一起移动，当first指针指向最后一个节点的时候(first下一个节点为NULL)，就说明second到达了倒数第k个节点
3.删除即可 second ->next = second->next->next
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
auto dummy = new ListNode(-1);
dummy->next = head;
auto first = dummy;
auto second = dummy;
while(n--) first = first->next;
while(first->next != NULL){
second = second->next;
first = first->next;
}
second->next = second->next->next;
return dummy->next;
}
};
237. 删除链表中的节点
例如，给定node指向5这个点，删除5这个点
真正意义删除要知道被删除节点的上一个点
假装删除，把这个点的值伪装成下一个点的值，把下一个点删掉即可
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
void deleteNode(ListNode* node) {
if(node->next){
node->val = node->next->val;
node->next = node->next->next;
}
return;
}
};
C++语法把node两个属性的值都一起替换为下一个节点的属性
*(node) = *(node->next);
83. 删除排序链表中的重复元素
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
auto *first = head;
while(first && first->next){
if(first->val == first->next->val){
first->next = first->next->next;
}else{
first = first->next;
//这里first可能移动到了空 所以要判断first是否空
}
}
return head;
}
};
82. 删除排序链表中的重复元素 II
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
auto dummy = new ListNode(-1);
dummy->next = head;
auto pre = dummy,cur = pre->next;
int cnt = 0;
while(pre && cur){
cnt = 0;
auto nxt = cur->next;
while(nxt && nxt->val == cur->val) {
cnt++;
nxt = nxt->next;
}
if(cnt >= 1){
pre->next = nxt;
cur = pre->next;
}else{
pre = pre->next;
cur = pre->next;
}
}
return dummy->next;
}
};
61. 旋转链表
两个指针，距离为k
(不需要用到虚拟头节点，头节点会改变时用到)
之后让first->next指向开头head，再让head指向现在的头(second->next)！
再让second->next指向空
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* rotateRight(ListNode* head, int k) {
if(!head) return NULL;
int n = 0;
for(auto p = head;p;p=p->next) n++;
k %= n;
auto first = head,second = head;
while(k--) first = first->next;
while(first->next){
first=first->next;
second=second->next;
}
first->next = head;
head = second->next;
second->next = NULL;
return head;
}
};
24. 两两交换链表中的节点
1.建立虚拟头节点，因为头节点可能会改变
2.三个指针
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
auto dummy = new ListNode(-1);
dummy->next = head;
for(auto p = dummy;p->next && p->next->next;){
auto a = p->next,b = a->next;
p->next = b;
a->next = b->next;
b->next = a;
p = a; //指向下一个新的两对前的最后一个点
}
return dummy->next;
}
};
206. 反转链表
两个翻转指针a，b；一个保留指针c保留b后面的链防止被删除，不需要虚拟头节点因为不需要用到首部前一个
分三步
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if(!head) return NULL;
auto a = head,b = head->next;
while(b){
auto c = b->next;
b->next = a;
a = b;
b = c;
}
head->next = NULL;//原来头是原来的第一节点 现在的最后一个节点所以指向空
head = a;
return head;
}
};
92. 反转链表 II
1.因为头节点会发生变化，设置虚拟头节点
2.a指针移动到翻转前一个点，b指针移动第一个翻转的点，d指针移动到最后一个翻转的点。c指针指向最后一个翻转的点的下一个点。然后翻转b~d之间的点和206题一样
3.连接a->d，b->c
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseBetween(ListNode* head, int m, int n) {
if(m == n) return head;
auto dummy = new ListNode(-1); //虚拟头节点
dummy->next = head;
//找到a和d
auto a = dummy,d = dummy;
for(int i=0;i<m-1;i++) {
a = a->next;//不设置虚拟头节点的话,如果n=1就找不到了a
}
for(int i=0;i<n;i++) d = d->next;
//找到b和c
auto b = a->next, c = d->next;
//翻转b和d之间的数字
for(auto first = b->next,second = b; first != c;){
auto third = first->next;
first->next = second;
second = first,first = third;
}
//连接
b->next = c;
a->next = d;
return dummy->next;
}
};
160. 相交链表
相遇：当指针p和指针q走的路程相等时相遇
考虑都走a+b+c的倍数，肯定会相遇
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
auto tempHeadA = headA;
auto tempHeadB = headB;
while(tempHeadA != tempHeadB){
if(tempHeadA) tempHeadA = tempHeadA->next;
else tempHeadA = headB;
if(tempHeadB) tempHeadB = tempHeadB->next;
else tempHeadB = headA;
}
return tempHeadB;
}
};
142. 环形链表 II
快慢指针
1.快指针慢指针从head头部出发，fast快指针每次走两步，slow慢指针每次走一步直到相遇。
2.把其中一个指针移动到head头部，快慢指针再每次走一步直到相遇，相遇点即为答案；
证明：利用快指针走动过的是慢指针的二倍，假设环起点坐标为x，第一次相遇点距离换起点距离为y。
可列公式2×(x+n1×c+y)=x+y+n2×c ，化简得x+y=(n2-n1)×c。
大白话说就是：非环部分的长度+环起点到相遇点之间的长度就是环的整数倍。
即x+y为环的整数倍
那么第一次相遇时我们现在距离环起点为y，所以只要再走x就到环起点了
再走x的话就让一个指针从head走，另一个从第一次相遇点走，每次都走1步
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
auto fast = head,slow = head;
while(fast && fast->next){
fast = fast->next;
fast = fast->next; //快指针移动两次
slow = slow->next; //慢指针移动1次
if(fast == slow){ //当快慢指针相遇时退出
break;
}
}
if(fast==NULL || fast->next == NULL)
return NULL;
else{
slow = head; //让其中一个指针移动到头部
while(fast != slow){ //再走到相遇点即可
fast = fast->next;
slow = slow->next;
}
return slow;
}
}
};
148. 排序链表
要求空间常数，时间O(nlogn)
因为快排用到递归(栈)，空间为logn；递归版归并空间消耗大；所以用迭代版归并
自底向上代码写法：先枚举长度为2，分成一半，左右归并；再枚举长度为4...
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* sortList(ListNode* head) {
int n = 0;
for(auto p = head; p ; p = p -> next) n++;
auto dummy = new ListNode(-1);
dummy->next = head;
for(int i=1; i<n ; i*=2){ //枚举每一段的一半长
auto cur = dummy;
for(int j=0; j+i<n ; j+=i*2){
auto left = cur->next; //左半段边界指针
auto right = cur->next; //右半段边界指针
for(int k=0;k<i;k++) right = right->next;
int l = 0,r = 0;
while(l < i && r < i && right){ //归并比较左右哪个大
if(left->val <= right-> val){
cur->next = left;
cur = left;
left = left->next;
l++;
}else{
cur->next = right;
cur = right;
right = right->next;
r++;
}
}
//一个先到了末尾 所以要拼接另一端的剩余部分
while(l < i){
cur->next = left;
cur = left;
left = left->next;
l++;
}
while(r < i && right){
cur->next = right;
cur = right;
right = right->next;
r++;
}
cur->next = right; //拼接下一段 这里的right最终指向了下一段的left
}
}
return dummy->next;
}
};
21. 合并两个有序链表
(线性合并) O(n)O(n)
1.新建头部的保护结点 dummy，设置 cur 指针指向 dummy。
2.如果p的值比q小，就将cur->next = p，否则让cur -> next = q (选小的先连接)
循环以上步骤直到 l1l1 或 l2l2 为空。
3.将剩余的 p或 q连 接到 cur 指针后边。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
auto dummmy = new ListNode(-1);
auto cur = dummmy;
auto p = l1,q = l2;
//选小的优先
while(p && q){
if(p->val <= q->val){
cur->next = p;
cur = p;
p = p->next;
}else{
cur->next = q;
cur = q;
q = q->next;
}
}
//加入剩余
while(p){
cur->next = p;
p = p->next;
}
while(q){
cur->next = q;
q = q->next;
}
// cur->next = (p != NULL ? p : q);
return dummmy->next;
}
};
