Leetcode刷题笔记（C++）——链表
Leetcode刷题笔记（C++）——链表
整理一下刷题过程中的思路，在这里进行一下总结与分享。
github地址：https://github.com/lvjian0706/Leetcode-solutions
github项目是刚刚新建的，陆续会将整理的代码以及思路上传上去，代码是基于C++与python的。同时会将基础的排序算法等也一并进行整理上传。
21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
/*
合并有序链表：类似归并排序的思路
*/
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode node(0);
ListNode* new_head = &node;
while(l1 && l2){
if(l1->val <= l2->val){
new_head->next = l1;
l1 = l1->next;
}
else{
new_head->next = l2;
l2 = l2->next;
}
new_head = new_head->next;
}
while(l1){
new_head->next = l1;
l1 = l1->next;
new_head = new_head->next;
}
while(l2){
new_head->next = l2;
l2 = l2->next;
new_head = new_head->next;
}
return node.next;
}
};
82. 删除排序链表中的重复元素 II
给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。
示例 1:
输入: 1->2->3->3->4->4->5
输出: 1->2->5
示例 2:
输入: 1->1->1->2->3
输出: 2->3
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
删除重复节点，只保留没有重复出现的数字:
1. 为了避免头节点重复需要删除，新建一个头节点指向原来的头节点，最后返回新建节点的next；
2. 定义last和fast节点用来遍历链表，并找出重复节点：
2.1 last和fast初始化为head节点，循环判断last和fast的next是否相等，如果相等，fast前进一位；
2.2 如果fast发生了变化，也就是last和fast不是同一个节点时，说明从last到fast之间是重复元素，new_head的next指向fast的下一个元素；
2.3 如果last和fast是同一个节点时，说明该元素不是重复元素，new_head前进到该元素；
2.4 last和fast前进一位，保证永远在new_head前面一位；
*/
ListNode* deleteDuplicates(ListNode* head) {
ListNode node(0);
ListNode* new_head = &node;
new_head->next = head;
ListNode* last = head;
ListNode* fast = head;
while(fast && fast->next){
while(fast->next && last->val == fast->next->val){
fast = fast->next;
}
if(last==fast){
new_head = last;
}
else{
new_head->next = fast->next;
}
last = new_head->next;
fast = new_head->next;
}
return node.next;
}
};
83. 删除排序链表中的重复元素
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例 1:
输入: 1->1->2
输出: 1->2
示例 2:
输入: 1->1->2->3->3
输出: 1->2->3
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
使用一个指针进行遍历：
1. 如果没有元素或者只有1个元素，直接返回；
2. 遍历链表，当下一个元素与当前元素相等时，指针的next指向next的next，用以删除重复的元素，直到下一个元素与当前元素不相等为止；
3. 指针指向下一个元素（与当前元素不相等的第一个元素）；
*/
ListNode* deleteDuplicates(ListNode* head) {
if(!head || !head->next) return head;
ListNode* newHead = head;
while(newHead && newHead->next){
if(newHead->next->val==newHead->val){
newHead->next = newHead->next->next;
}
else{
newHead = newHead->next;
}
}
return head;
}
};
86. 分隔链表
给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。
你应当保留两个分区中每个节点的初始相对位置。
示例:
输入: head = 1->4->3->2->5->2, x = 3
输出: 1->2->2->4->3->5
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
分隔链表：
定义两个节点small_head和large_head，前者作为头节点存储小于x的节点，后者作为头节点存储大于等于x的节点，最后进行拼接；
注意结果链表的尾部应该为null；
*/
ListNode* partition(ListNode* head, int x) {
ListNode node1(0);
ListNode* small_head = &node1;
ListNode node2(0);
ListNode* large_head = &node2;
while(head){
if(head->val<x){
small_head->next = head;
small_head = small_head->next;
}
else{
large_head->next = head;
large_head = large_head->next;
}
head = head->next;
}
small_head->next = node2.next;
large_head->next = NULL;
return node1.next;
}
};
92. 反转链表 II
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
反转从m到n的链表：迭代法
使用first指针指向位置m，first_pre指向m-1，temp设为null，last指向位置m+1，last_next指向位置n+1；
使用fist,last以及temp将位置m到n进行反转，接着将first_pre指向反转后的子链表头，反转后的子链表尾指向n+1；
*/
ListNode* reverseBetween(ListNode* head, int m, int n) {
ListNode* first = head;
ListNode node(0);
ListNode* first_pre = &node;
first_pre->next = head;
/*
将first指针指向位置m，first_pre指向位置m-1；
*/
for(int i=0; i<m-1; i++){
first = first->next;
first_pre = first_pre->next;
}
ListNode* last = first->next;
ListNode* temp = NULL;
/*
使用fist,last以及temp将位置m到n进行反转,此时temp指向位置m，first指向位置m+1;
*/
for(int i=m; i<n+1; i++){
first->next = temp;
temp = first;
first = last;
if(last) last = last->next;
}
first_pre->next->next = first;
first_pre->next = temp;
return node.next;
}
};
138. 复制带随机指针的链表
给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。
要求返回这个链表的 深拷贝。
我们用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：
val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。
/*
// Definition for a Node.
class Node {
public:
int val;
Node* next;
Node* random;
Node(int _val) {
val = _val;
next = NULL;
random = NULL;
}
};
*/
class Solution {
public:
/*
复制带随机指针的链表：深拷贝
1. 循环遍历链表，一边遍历一边新建节点，将新节点赋值为与该节点一样的值，然后插入到该节点后边；
2. 再次循环遍历新链表，步长为2，一边遍历一边将后边的节点（1中新建的节点）的random赋值为与前边节点（原始节点）一致；
3. 将新链表拆分
*/
Node* copyRandomList(Node* head) {
Node* insert_head = head;
while(insert_head){
Node* temp_node = new Node(insert_head->val);
temp_node->next = insert_head->next;
insert_head->next = temp_node;
insert_head = insert_head->next->next;
}
Node* random_head = head;
while(random_head && random_head->next){
if(random_head->random) random_head->next->random = random_head->random->next;
else random_head->next->random = NULL;
random_head = random_head->next->next;
}
Node node(0);
Node* copy_head = &node;
Node* new_head = head;
while(new_head && new_head->next){
copy_head->next = new_head->next;
new_head->next = new_head->next->next;
new_head = new_head->next;
copy_head = copy_head->next;
}
copy_head->next = NULL;
return node.next;
}
};
141. 环形链表
给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
进阶：
你能用 O(1)（即，常量）内存解决此问题吗？
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
判断链表是否有环，使用快慢指针
快指针每次走两步，慢指针每次走一步，看是否可以碰面；主要关注边界情况
*/
bool hasCycle(ListNode *head) {
if(!head || !head->next) return false;
ListNode* fast = head;
ListNode* slow = head;
while(fast && fast->next){
fast = fast->next->next;
slow = slow->next;
if(fast==slow) return true;
}
return false;
}
};
142. 环形链表 II
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
循环链表：
1. 首先判断是否是环，使用快慢指针，快指针每次走2步，慢指针每次走1步，看是否相遇，不相遇则返回null；
2. 如果相遇，设慢指针走了s，则快指针已经走了2s，假设从head到环的入口为a，环的长度为b，则s=nb，快指针比慢指针多走了nb；
3. 想要计算环的入口a，可以使用两个指针，一个在head处走a步，一个在相遇处走a步，此时，一个指针的位置为a，一个为a+nb，因为有环，所以a=a+nb；
4. 最终的相遇位置为环的入口；
*/
ListNode *detectCycle(ListNode *head) {
if(!head || !head->next) return NULL;
ListNode* fast = head;
ListNode* slow = head;
while(fast && fast->next){
fast = fast->next->next;
slow = slow->next;
if(fast==slow){
slow = head;
while(fast != slow){
fast = fast->next;
slow = slow->next;
}
return slow;
}
}
return NULL;
}
};
143. 重排链表
给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1:
给定链表 1->2->3->4, 重新排列为 1->4->2->3.
示例 2:
给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
/*
递归反转链表
*/
ListNode* reverseList(ListNode* head){
if(!head || !head->next) return head;
ListNode* new_head = reverseList(head->next);
head->next->next = head;
head->next = nullptr;
return new_head;
}
/*
重排列链表：将后半部分的链表倒序插入到前半部分链表中；
1. 使用快慢指针找到后半部分链表；
2. 反转后半部分链表；
3. 将右半部分链表插入到左半部分链表中；
*/
void reorderList(ListNode* head) {
if(!head || !head->next) return;
ListNode* fast = head->next;
ListNode* slow = head;
while(fast && fast->next){
fast = fast->next->next;
slow = slow->next;
}
ListNode* right_half = reverseList(slow->next);
slow->next = nullptr;
ListNode* new_head = head;
while(new_head && right_half){
ListNode* temp = right_half->next;
right_half->next = new_head->next;
new_head->next = right_half;
right_half = temp;
new_head = new_head->next->next;
}
/*
当右半部分链表还有一个元素没有插入进去时，单独处理；
*/
if(right_half){
right_half->next = new_head->next;
new_head->next = right_half;
}
}
};
148. 排序链表
在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。
示例 1:
输入: 4->2->1->3
输出: 1->2->3->4
示例 2:
输入: -1->5->3->4->0
输出: -1->0->3->4->5
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
新建头节点，进行归并排序；
*/
ListNode* mergeSort(ListNode* left, ListNode* right){
ListNode node(0);
ListNode* new_head = &node;
while(left && right){
if(left->val<right->val){
new_head->next = left;
left = left->next;
}
else{
new_head->next = right;
right = right->next;
}
new_head = new_head->next;
}
while(left){
new_head->next = left;
left = left->next;
new_head = new_head->next;
}
while(right){
new_head->next = right;
right = right->next;
new_head = new_head->next;
}
return node.next;
}
/*
链表排序：
O(nlogn) 时间复杂度以及常数级空间复杂度，考虑归并排序
使用快慢指针找链表的中点，将链表分为前半部分和后半部分，递归的对前半部分以及后半部分进行排序，最后对两部分进行总的排序
其中，在分割时，需要将前半部分的尾指针next赋为null，将链表切断，否则会无限递归；后半部分的起始点则为slow->next；
*/
ListNode* sortList(ListNode* head) {
if(!head || !head->next) return head;
ListNode* fast = head->next;
ListNode* slow = head;
while(fast && fast->next){
fast = fast->next->next;
slow = slow->next;
}
ListNode* half = slow->next;
slow->next = NULL;
return mergeSort(sortList(head), sortList(half));
}
};
206. 反转链表
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
原地反转链表：方法1.递归
1. 递归结束条件：如果head为空或者链表只有1个节点，不需要反转，直接返回；
2. 当head->next之后的节点已经反转好了，将新的头结点保存为new_head；
3. 此时，头节点指向新链表的尾节点，需要将新链表的尾节点指向头节点（反转head和head->next），head->next->next = head；
4. 将头节点的next赋为空；
5. 返回新链表的头节点；
*/
ListNode* reverseList(ListNode* head) {
if(!head || !head->next) return head;
ListNode* new_head = reverseList(head->next);
head->next->next = head;
head->next = NULL;
return new_head;
}
};
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
/*
原地反转链表：方法2.迭代
1. 递归结束条件：如果head为空或者链表只有1个节点，不需要反转，直接返回；
2. 使用三个指针，每次将当前指针指向前一个位置的指针，然后将三个指针同时向后移动一位；
*/
ListNode* reverseList(ListNode* head) {
ListNode* new_head = NULL;
while(head){
ListNode* head_next = head->next;
head->next = new_head;
new_head = head;
head = head_next;
}
return new_head;
}
};
234. 回文链表
请判断一个链表是否为回文链表。
示例 1:
输入: 1->2
输出: false
示例 2:
输入: 1->2->2->1
输出: true
进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
/**
* 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 || !head->next) return head;
ListNode* new_head = reverseList(head->next);
head->next->next = head;
head->next = NULL;
return new_head;
}
/*
判断是否是回文链表：
1. 使用快慢指针找到链表中点，将链表断开；
2. 将后半部分链表反转；
3. 比较两个链表的相同位置的值是否一致；
*/
bool isPalindrome(ListNode* head) {
if(!head || !head->next) return true;
ListNode* fast = head->next;
ListNode* slow = head;
while(fast && fast->next){
fast = fast->next->next;
slow = slow->next;
}
ListNode* right = reverseList(slow->next);
slow->next = NULL;
while(head && right){
if(head->val != right->val) return false;
head = head->next;
right = right->next;
}
return true;
}
};