LeetCode+剑指 链表相关
☺☺☺
（1）剑指06： 从尾到头打印链表
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
限制：
0 <= 链表长度 <= 10000
法1：思路：栈，利用栈先进后出的特性。
放入栈中的是节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
stack<ListNode*> node; //存放各节点的地址
vector<int> res; //存放输入结果
ListNode* p=head;
while(p!=NULL){//注意判断结点空的NULL
node.push(p); //节点地址放入node栈中
p=p->next;
}
while(!node.empty()){//
p=node.top();
res.push_back(p->val);
node.pop();
}
return res;
}
};
法2
思路：遍历链表，同时把值放入vector中，最后用reverse翻转。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
vector<int> res; //存放结果
while(head!=NULL){
res.push_back(head->val);
head=head->next;
}
reverse(res.begin(),res.end());
return res;
}
};
暂时不用。。。
同法1，用栈，不过放入栈中的是值，而不是节点。
class Solution {
public:
vector<int> reversePrint(ListNode* head) {
stack<int>temp;
vector<int> num;
if(head == NULL){
return num;
}else{
while(head){
temp.push(head->val);
head = head->next;
}
while(!temp.empty()){
num.push_back(temp.top());
temp.pop();
}
}
return num;
}
}
☺☺☺
（2）剑指24. 反转链表（LC206）
知识点！！
重点理解：
1->2->3->4->5->null
翻转后是
5->4->3->2->1->null
其实每个链表后面的null我们是看不到的，所以它就不算一个结点。
例：
1->2
刚开始pNode->1
pr->pNode（实质上是pr通过pNode指向了pNode指向的结点）
现在pNode移动了，指向2
问？pr指向谁？
答：pr指向1
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
法1：双指针（简单版本）
双指针 tmp、head
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* tmp = NULL;
while (head!=NULL)
{
ListNode* pnext = head->next; //定义一个pnext指向head的下一个节点
head->next = tmp; //改变指向
tmp = head; //移动tmp
head = pnext; //移动head
}
return tmp;
}
};
思路：同上（双指针），变个表达方式。
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* ReverseList(ListNode* pHead) {
ListNode* pReverHead=NULL; //定义一个备用的指针。指向翻转后链表的头节点。
ListNode* pNode=pHead; //定义一个指向头节点的指针
ListNode* pPrev=NULL;
while(pNode!=NULL){
ListNode* pNext=pNode->next;
if(pNext==NULL){
pReverHead=pNode;
}
pNode->next=pPrev;
pPrev=pNode;
pNode=pNext;
}
return pReverHead;
}
};
☺☺☺
（3）92. 反转链表 II 【中等】
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
看遍评论区所有答案，找到一个最好理解的！（翻译的某java哈哈）
**分析
第一步：找到待反转节点的前一个节点。
第二步：反转m到n这部分。
第三步：将反转的起点的next指向反转的后面一部分。
第四步：将第一步找到的节点指向反转以后的头节点。
如下图所示：
**
/**
* 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(!head || !head->next || m<0 || n<0 || m>=n) return head;//异常情况处理
ListNode* res=new ListNode(0); //新建一个节点
res->next=head; //新节点的next指向头节点，这样头结点就可以随意移动了，最后res->next就可
ListNode* node = res;
//找到需要反转的那一段的上一个节点。
for (int i = 1; i < m; i++) {
node = node->next;
}
//node.next就是需要反转的这段的起点。
ListNode* nextHead = node->next;
ListNode* next = NULL;
ListNode* pre = NULL;
//反转m到n这一段
for (int i = m; i <= n; i++) {//翻转位置m~n处的链表
next = nextHead->next;
nextHead->next = pre;
pre = nextHead;//更新指针
nextHead = next;//更新指针
}
//将反转的起点的next指向next。
node->next->next = next;
//需要反转的那一段的上一个节点的next节点指向反转后链表的头结点
node->next = pre;
return res->next;
}
};
默写一遍：（简洁）
class Solution {
public:
ListNode* reverseBetween(ListNode* head, int m, int n) {
ListNode* res=new ListNode(0);
res->next=head;
ListNode* node=res;
for(int i=1; i<m; i++){
node=node->next;
}
ListNode* phead=node->next;
ListNode* pre=NULL;//定义一前一后指针
ListNode* pnext=NULL;
for(int i=m; i<=n; i++){
pnext=phead->next;
phead->next=pre;
pre=phead;
phead=pnext;
}
node->next->next=phead;
node->next=pre;
return res->next;
}
};
☺☺☺
（4）LC237. 删除链表中的节点
这是一道看不懂问题的题，看了评论能笑死人！ 啥意思啊。越看越想笑。。
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
现有一个链表 – head = [4,5,1,9]，它可以表示为:
4 -> 5 -> 1 -> 9
示例 1:
输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明:
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。
题目出得很没有意思 一道简单题 题目描述很随意 还搞出4–5--1–9删掉5之后419 这样子很容易误导大家 让大家以为是遍历链表删除特定元素 你直接说给定链表中一个特定节点（不是尾节点）请删除该节点 有时候简洁更好 为了描述清楚用了很多图例反而没有达到描述清楚的效果
这个题的关键在于要删除它的当前节点，而不知道前一个结点，而每个节点比较关键的就是data,把当前节点的data换成下一节点的data,链接地址换成下一节点的链接地址，也就变相的把当前节点删除了
后来想想，这题牛！确实是那么一回事！
覆盖法
/**
* 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) {
node->val = node->next->val;
node->next = node->next->next;
}
};
结果：
加粗样式
☺☺☺
（5）剑指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 被删除的节点
思路
构建头部 dummy 节点，（一个指针操作）
后面的操作就可以转化为一般化得链表节点移除问题。
只用了一个指针
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* deleteNode(ListNode* head, int val) {
ListNode* dummy=new ListNode(0); //新建一个节点
dummy->next=head;
ListNode* pre=dummy;
while(pre && pre->next){ //注意里面条件，考虑到尾节点
if(pre->next->val==val){//注意“==”
pre->next=pre->next->next;//跨过要删除的节点
}
pre=pre->next;
}
return dummy->next;
}
};
或者：
ListNode* deleteNode(ListNode* head, int val) {
ListNode* dummy=new ListNode(0);
dummy->next=head;
ListNode* tmp=dummy;
while(tmp->next){
if(tmp->next->val==val){
tmp->next=tmp->next->next;
break;
}
tmp=tmp->next;
}
return dummy->next;
}
思路同上，新建一个节点，双指针操作
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* deleteNode(ListNode* head, int val) {
ListNode* dummy=new ListNode(0);
dummy->next=head;
ListNode* pre=dummy; //定义一前一后节点
ListNode* cur=head;
while(cur){
if(cur->val==val){
pre->next=cur->next;
break;//不写也行
}
pre=cur;
cur=cur->next;
}
return dummy->next;
}
};
关于是否建立一个头部 dummy 节点。个人理解：像第（5）题，单纯删除一个节点，可能第一个节点也要删除，所以建立一个比它靠前的节点。
像下面的第（6）题，删除重复的节点，可以不用管第一个节点，不用考虑第一个节点是否需要删除。因为即使第一第二个节点相同，直接删第二个就行。
但建立不建立，不是必须的。
它们的共同点，都需要有一个while循环来驱使指针前进。
☺☺☺
（6）LC83. 删除排序链表中的重复元素Ⅰ
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例 1:
输入: 1->1->2
输出: 1->2
示例 2:
输入: 1->1->2->3->3
输出: 1->2->3
法1：直接法（一个指针操作）
/**
* 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) {
//一个指针
ListNode* p=head;
while(p && p->next){
if(p->val==p->next->val){
p->next=p->next->next;
} //这样else的原因是有这种情况： 1 1 1 ，每次都判断一下
else p=p->next;
}
return head;
}
};
法2：双指针，，没有定义新节点
/**
* 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) {
if(head==NULL)
return head;
//双指针
ListNode* pre=head; //定义一个慢指针
ListNode* cur=head->next; //定义一个快指针
while(pre->next!=NULL){
if(pre->val==cur->val){ //元素相等
pre->next=cur->next; //跨过一个元素
cur=cur->next; //移动指针
}
else{ //注意if else 对立关系
pre=cur;
cur=cur->next;
}
}
return head;
}
};
☺☺☺
（7）LC82. 删除排序链表中的重复元素 II 【中等】
给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。
示例 1:
输入: 1->2->3->3->4->4->5
输出: 1->2->5
示例 2:
输入: 1->1->1->2->3
输出: 2->3
法1：双指针。新建一个头节点，因为第一个节点也有可能删除。
法1比法2好理解！
/**
* 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) {
if (!head || !head->next)
return head;
ListNode* dummy = new ListNode(-1);
dummy->next = head;
ListNode* pre = dummy;
ListNode* cur = head;
while (cur && cur->next) {
if (cur->val == cur->next->val) {
while (cur->next && cur->val == cur->next->val) {
cur = cur->next;
}
pre->next = cur->next;
cur = cur->next;
} else {
pre = cur;
cur = cur->next;
}
}
return dummy->next;
}
};
法2：双指针（方法同上）
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
*/
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead)
{
if (pHead==NULL){
return NULL;
}
ListNode* pre=new ListNode(1); //新建一个头结点，括号里面任何数字都可以（分配一个数的大小）
ListNode* p=pre;
ListNode* q=pHead;
pre->next=pHead;
while(q!=NULL && q->next!=NULL){
int i=0;
while(q->next->val==q->val && q->next!=NULL){
q=q->next;
i++;//用多少个重复的
}
if(i==0)
p=q;//保证第一个指针向右移
else
p->next=q->next; //如果重复，直接跳掉q值相同的后面
q=q->next;//q始终用移动
}
return pre->next;
}
};
☺☺☺
（8）剑指22. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
法2：双指针（快慢指针）快慢指针，先让fast比slow多走k步，然后一起走，当fast到尾部时，slow就是所求的倒数第k 个节点。
就像一个固定尺寸的尺子移动一样。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* getKthFromEnd(ListNode* pListHead, int k) {
if (pListHead==NULL || k==0){
return NULL;
}
ListNode* fast=pListHead;
ListNode* slow=pListHead;
for( int i=1;i<k;i++){ //从1开始好理解 //刚开始pA已经指向了头结点，走k-1步就行了
if(fast->next!=NULL){
fast=fast->next;
}
}
while(fast->next!=NULL){
fast=fast->next;//一起走
slow=slow->next;
}
return slow;
}
};
法1：倒数第k个节点，转化为正数第几个节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* getKthFromEnd(ListNode* head, int k) {
int len=0;
ListNode* p=head;
while(p!=NULL){ //计算链表的长度
len++;
p=p->next;
}
int r=len-k+1; //从倒数第k个节点，推导出正数第几个节点
p=head; //指针重新指向头节点
for(int i=1; i<r; i++){ //让指向指向第r个节点
p=p->next;
}
return p; //返回指向第r个节点的指针
}
};
☺☺☺
（9）19. 删除链表的倒数第N个节点【中等】
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：
给定的 n 保证是有效的。
进阶：
你能尝试使用一趟扫描实现吗？
双指针
**解题思路
解题思路与官方所给方法相同，使用两个指针分别指向头节点和第n个节点，当后一个指针到达最后一个节点时，第一个指针正好位于倒数第n+1个节点处，删除第一个指针的下一个结点即可。
**
/**
* 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) {
ListNode* first = new ListNode(0);
first->next = head; //添加头节点，便于操作
ListNode* ptr = first; //搜索节点
ListNode* current = first; //中间节点
for (int i = 0; i < n; i++)//将该指针指第n个节点
{
current = current->next;
}
while (current->next != NULL) //到达最后一个节点
{
ptr = ptr->next;
current = current->next;
}
ListNode* p = ptr->next; //新建一个p是因为要释放p 否则 ptr->next = p->next->next; 即可
ptr->next = p->next; //删除ptr指向节点
delete p; //释放空间
return first->next;
}
};
☺☺☺
（10）剑指52. 两个链表的第一个公共节点（LC161）
输入两个链表，找出它们的第一个公共节点。
示例 1：
输入：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 个节点。
示例 3：
输入：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。
法2 太浪漫了 两个结点不断的去对方的轨迹中寻找对方的身影，只要二人有交集，就终会相遇❤
我们使用两个指针 node1，node2 分别指向两个链表 headA，headB 的头结点，然后同时分别逐结点遍历，当 node1 到达链表 headA 的末尾时，重新定位到链表 headB 的头结点；当 node2 到达链表 headB 的末尾时，重新定位到链表 headA 的头结点。这样，当它们相遇时，所指向的结点就是第一个公共结点。
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
if(!headA || !headB) return nullptr;
ListNode* p1 = headA, * p2 = headB;
while(p1 != p2) {
if(p1) p1=p1->next;
else p1=headB;
if(p2) p2=p2->next;
else p2=headA;
}
return p1;
}
};
法1
思路：找出2个链表的长度，然后让长的先走两个链表的长度差，然后再一起走；
第一个公共点之后的next都是一样的，所以必然有公共的尾部；；
原来公共结点的意思是两个链表相遇之后后面都是一样的，我还以为是交叉的两个链表
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
int length1=GetLength(pHead1);
int length2=GetLength(pHead2);
ListNode* pNode1=pHead1;
ListNode* pNode2=pHead2;
int lengthDif=0;
if(length1>=length2){//如果第一个链表比第二个链表长
lengthDif=length1-length2; //求出长度差
for(int i=0;i<lengthDif;i++) //让两者起步相同
pNode1=pNode1->next;
}
if(length1<length2){//如果第一个链表比第二个链表短
lengthDif=length2-length1; //求出长度差
for(int i=0;i<lengthDif;i++)
pNode2=pNode2->next;
}
//之前有bug
while((pNode1!=nullptr)&&(pNode2!=nullptr)&&(pNode1!=pNode2)){ //注意不是：pNode1->val!=pNode2->val ,值相等不代表是同一个节点
// if(pNode1->val==pNode2->val)
// return pNode1;
pNode1=pNode1->next;
pNode2=pNode2->next;
}
ListNode* pCommonNode=pNode1;
return pCommonNode;
}
int GetLength(ListNode* pHead){ //求长度的函数
ListNode* pNode=pHead;
int length=0;
while(pNode!=nullptr){
length++;
pNode=pNode->next;
}
return length;
}
};
☺☺☺
（11）剑指23：链表中环的入口节点【中等】（LC142）
题目描述
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
双指针
先说个定理：两个指针一个fast、一个slow同时从一个链表的头部出发fast一次走2步，slow一次走一步，如果该链表有环，两个指针必然在环内相遇，此时只需要把其中的一个指针重新指向链表头部，另一个不变（还在环内），这次两个指针一次走一步，相遇的地方就是入口节点。
为什么必然在环内相遇？假如该链表是循环链表，那我们可以定义两个指针，一个每次向前移动两个节点，另一个每次向前移动一个节点。这就和田径比赛是一样的，假如这两个运动员跑的是直道，那快的运动员和慢的运动员在起点位于同一位置，但快的运动员必将先到达终点，期间这两个运动员不会相遇。而如果绕圈跑的话（假设没有米数限制），跑的快的运动员在超过跑的慢的运动员一圈的时候，他们将会相遇，此刻就是循环链表。
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast=head;
ListNode* low=head;
while(fast && fast->next){
fast=fast->next->next;
low=low->next;
if(fast==low){
low=head;//low从链表头出发
while(fast!=low){//fast从相遇点出发
fast=fast->next;
low=low->next;
}
return low;
}
}
return NULL;//一定得写
}
};
如果仅仅判断是否存在环（LC141）
定理：两个指针一个fast、一个slow同时从一个链表的头部出发fast一次走2步，slow一次走一步，如果该链表有环，两个指针必然在环内相遇，
class Solution {
public:
bool hasCycle(ListNode *pHead) {
ListNode*fast=pHead,*low=pHead;
while(fast&&fast->next){ //一定要写这两个条件
fast=fast->next->next;
low=low->next;
if(fast==low) //注意==
return true;
}
return false;
}
};
** 不能犯错：while(fast!=low)。因为一开始它们就不一样！进不去循环的。**
☺☺☺
以下连续3道题运用相同的代码块（归并排序？）
（12）剑指25. 合并两个排序的链表（LC21）
传说中的归并排序？
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
思路：新建一个头节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* pHead1, ListNode* pHead2) {
if(pHead1==NULL&&pHead2!=NULL)return pHead2;
if(pHead2==NULL&&pHead1!=NULL)return pHead1;
if(pHead2==NULL&&pHead1==NULL)return NULL;
ListNode* head=new ListNode(1);//头结点前面附加一结点（当原链表头结点可能会变化时都可以考虑新建
ListNode* root=head;//新链表结点指针
while(pHead1!=NULL&&pHead2!=NULL){
if(pHead1->val<pHead2->val){ //比较l1和l2各结点大小，归并
head->next=pHead1;
head=head->next;
pHead1=pHead1->next;
}
else{
head->next=pHead2;
head=head->next;
pHead2=pHead2->next;
}
}
if(pHead1==NULL){//处理剩余结点
head->next=pHead2;
}
if(pHead2==NULL){
head->next=pHead1;
}
return root->next;//返回头结点指针
}
};
☺☺☺
（13）23. 合并K个排序链表
基于合并2个排序链表
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
思路：基于合并两个链表，取第一个链表与第二个链表合并，然后将合并的链表再与第三个链表合并，依次类型。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
int size = lists.size();
if (size == 0) {
return nullptr;
}
if (size == 1) {
return lists[0];
}
ListNode *p = lists[0];
for (int i = 1; i < size; ++i) {
p = mergeTwoLists(p, lists[i]);
}
return p;
}
ListNode* mergeTwoLists(ListNode* pHead1, ListNode* pHead2) {
ListNode* head=new ListNode(1);//头结点前面附加一结点（当原链表头结点可能会变化时都可以考虑新建
ListNode* root=head;//新链表结点指针
while(pHead1!=NULL&&pHead2!=NULL){
if(pHead1->val<pHead2->val){
head->next=pHead1;
head=head->next;
pHead1=pHead1->next;
}
else{
head->next=pHead2;
head=head->next;
pHead2=pHead2->next;
}
}
if(pHead1==NULL){//处理剩余结点
head->next=pHead2;
}
if(pHead2==NULL){
head->next=pHead1;
}
return root->next;//返回头结点指针
}
};
☟ tip：找到一个链表中间节点的方法，慢指针走1步，快指针走2步；当快指针走到尾，慢指针走到中间。
ListNode *slow = head, *fast = head, *pre = head;
while (fast && fast->next){
pre = slow;
slow = slow->next;
fast = fast->next->next;
}//退出循环时，fast或fast->next = nullptr,slow指向中部位置
pre->next = NULL; //将左右子链表断开处理
☺☺☺
（14）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
思路
利用归并的思想，递归地将当前链表分为两段，然后mergeTwoLists，
分两段的方法是使用 fast-slow 法，用两个指针，一个每次走两步，一个走一步，知道快的走到了末尾，然后慢的所在位置就是中间位置，这样就分成了两段。
* 主要考察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:
ListNode* sortList(ListNode* head) {
if (!head || !head->next) return head;
ListNode *slow = head, *fast = head, *pre = head;
while (fast && fast->next){
pre = slow;
slow = slow->next;
fast = fast->next->next;
}//退出循环时，fast或fast->next = nullptr,slow指向中部位置
pre->next = NULL; //将左右子链表断开处理
ListNode* l=sortList(head); //这2步使用递归，画个图就明白
ListNode* r=sortList(slow);
return mergeTwoLists(l, r);
}
ListNode* mergeTwoLists(ListNode* pHead1, ListNode* pHead2) {
if(pHead1==NULL&&pHead2!=NULL)return pHead2;
if(pHead2==NULL&&pHead1!=NULL)return pHead1;
if(pHead2==NULL&&pHead1==NULL)return NULL;
ListNode* head=new ListNode(1);//头结点前面附加一结点（当原链表头结点可能会变化时都可以考虑新建
ListNode* root=head;//新链表结点指针
while(pHead1!=NULL&&pHead2!=NULL){
if(pHead1->val<pHead2->val){
head->next=pHead1;
head=head->next;
pHead1=pHead1->next;
}
else{
head->next=pHead2;
head=head->next;
pHead2=pHead2->next;
}
}
if(pHead1==NULL){//处理剩余结点
head->next=pHead2;
}
if(pHead2==NULL){
head->next=pHead1;
}
return root->next;//返回头结点指针
}
};
☺☺☺
（15）剑指35. 复杂链表的复制【中等】（LC138）
有点难，记住思路算了！
题目描述
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
思路
三步法
/*
// 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:
//总的函数三步合一
Node* copyRandomList(Node* pHead){
CloneNodes(pHead);
ConnectRandomNodes(pHead);
return ReConnectNodes(pHead);
}
//第一步：复制结点与next指针
//复制原始链表的任一节点N并创建新节点N'，再把N'链接到N的后边
void CloneNodes(Node* pHead){
Node* pNode=pHead;
while(pNode!=NULL){
Node* pCloned=new Node(0);
pCloned->val=pNode->val;
pCloned->next=pNode->next;
pCloned->random=NULL;
pNode->next=pCloned;
pNode=pCloned->next;
}
}
//第二步：复制random指针
//如果原始链表上的节点N的random指向S，则对应的复制节点N'的random指向S的下一个节点S'
void ConnectRandomNodes(Node* pHead){
Node* pNode=pHead;
while(pNode!=NULL){
Node* pCloned=pNode->next;
if(pNode->random!=NULL)
pCloned->random=pNode->random->next;
pNode=pCloned->next;
}
}
//第三步：拆分链表
//把得到的链表拆成两个链表，奇数位置上的结点组成原始链表，偶数位置上的结点组成复制出来的链表
Node* ReConnectNodes(Node* pHead){
Node* pNode=pHead;
Node* pClonedHead=NULL;
Node* pClonedNode=NULL;
//初始化
if(pNode!=NULL){
pClonedHead=pClonedNode=pNode->next;
pNode->next=pClonedNode->next;
pNode=pNode->next;
}
//循环
while(pNode!=NULL){
pClonedNode->next=pNode->next;
pClonedNode=pClonedNode->next;
pNode->next=pClonedNode->next;
pNode=pNode->next;
}
return pClonedHead;
}
};
☺☺☺
（16）2. 两数相加【中等】
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
其实不用思考从哪边开始，看那个输出结果，就是从左往右，进位在右边。
** h->next=new ListNode(1);**
ListNode(1)里的数字是几，就是新建一个为几的节点。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* head=new ListNode(-1);//存放结果的链表
ListNode* h=head;//移动指针
int sum=0;//每个位的加和结果
bool carry=false;//进位标志
while(l1!=NULL||l2!=NULL)
{
sum=0;
if(l1!=NULL)
{
sum+=l1->val;
l1=l1->next;
}
if(l2!=NULL)
{
sum+=l2->val;
l2=l2->next;
}
if(carry) //是否有进位
sum++;
h->next=new ListNode(sum%10);
h=h->next;
carry=sum>=10?true:false;
}
if(carry) //处理最后一个进位
{
h->next=new ListNode(1);
}
return head->next;
}
};
☺☺☺
（17）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
说明:
应当保持奇数节点和偶数节点的相对顺序。
链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。
问题：在链表中，将所有奇数序号的结点放到前面，偶数序号的结点放在后面，要求就地解决
与问题“调整数组中奇数偶数顺序”区别在于前者调整结点，而后者调整的是值
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* oddEvenList(ListNode* head) {
if(!head) return head;
ListNode* odd = head; //奇数序列结点指针与头指针
ListNode* evenhead = head->next,*even = evenhead; //偶数序列结点指针与头指针
while(even && even->next){//偶数序列指针判断(循环时一般用后面的指针来判断是否结束循环) 对于走两步的指针p均需要判断p与p->next是否为空
odd->next = odd->next->next; //连接奇数序列结点,每次走两步 ，先连接前面的指针
even->next = even->next->next;//连接偶数序列结点
odd = odd->next; //指向下一个奇结点
even = even->next;
}
odd->next = evenhead; //连接奇序列链表和偶序列链表
return head;
}
};
☺☺☺
（18）234. 回文链表
请判断一个链表是否为回文链表。
示例 1:
输入: 1->2
输出: false
示例 2:
输入: 1->2->2->1
输出: true
法1：将链表的值放入数组中，然后在数组中采用双指针比较。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool isPalindrome(ListNode* head) {
if(head==NULL) return true;
if(head->next==NULL)return true;
ListNode *i=head;
vector<int> val;
//将链表值放入数组
while(i!=NULL){
val.push_back(i->val);
i=i->next;
}
int m=0,n=val.size()-1;
while(m<n){
if(val[m]!=val[n]) //前后移动比较
return false;
m++;
n--;
}
return true;
}
};
法2：用快慢指针法找到链表中部位置，然后翻转右半链表，判断右边链表与左边链表是否相等
发现有些题就是一些基础题的组合。比如这道题里面的定位到中心呀，翻转链表呀，都是前面题里面出现过的。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool isPalindrome(ListNode* head) {
if (!head || !head->next) return true; //异常情况处理,为空结点或者一个结点时
ListNode *slow = head, *fast = head;
while (fast && fast->next){//快慢指针法，让slow指向链表中部位置
slow = slow->next;
fast = fast->next->next;
} //退出时，fast为最后一个结点或者null，slow处在中间位置（与结点数有关，左子链表head~slow-1, 右子链表为slow~end，右子链表比左子链表长一或者相等）
//2个链表不断开也行，和上面（14）题一样，断开也行，不影响。
ListNode* right = reverseList(slow);//反转右边链表
ListNode* left = head;
while(left && right){//比较左右子链表是否相等
if(left->val == right->val){
left = left->next;
right = right->next;
}
else return false;
}
return true;
}
//函数：反转链表
ListNode* reverseList(ListNode* head) {
ListNode* tmp = NULL;
while (head!=NULL)
{
ListNode* pnext = head->next; //定义一个pnext指向head的下一个节点
head->next = tmp; //改变指向
tmp = head; //移动tmp
head = pnext; //移动head
}
return tmp;
}
};