题目1：24 两两链表交换链表中的节点
题目链接：两两交换链表中的节点
对题目的理解：两两交换链表中相邻节点（只进行节点交换）
关键在于终止遍历判断条件
节点数量要分奇偶：
对于奇数个节点，最后一个不做交换，当cur->next->next==NULL终止遍历
对于偶数个节点，当cur->next==NULL终止遍历
对于一组数据来说，整个操作（需要涉及到原链表的第3个节点）
设置中间临时变量法
注意这里的cur=dummyhead，因为要对head进行操作，所以要直到head的前面节点，即dummyhead.
- 时间复杂度：O(n)
- 空间复杂度：O(1
/** * 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* swapPairs(ListNode* head) { ListNode* dummyhead = new ListNode(0); dummyhead->next = head; ListNode* cur = dummyhead; ListNode* temp; ListNode* temp1; while(cur->next!=nullptr&&cur->next->next!=nullptr) //循环条件顺序不能变，若顺序颠倒，则可能出现cur->next为空的现象，那么cur->next->next就是对空指针进行操作 //并且这里一定要是&&,只有当这两个都不为空的时候，才能进行循环，因为后面会用到这两个值 { temp = cur->next; //第一个节点 temp1 = cur->next->next->next;//第三个节点 cur->next = cur->next->next; cur->next->next = temp; temp->next = temp1;//也可以写成 cur->next->next->next = temp1; cur = cur->next->next; } return dummyhead->next; } };
题目2：19 删除链表的倒数第N个节点
题目链接：删除链表的倒数第N个节点
对题目的理解 ：删除链表的第N个节点
自己的思路
循环各个节点并计数，倒数节点位置与正数节点位置满足一个等式关系，计数的同时计算其对于倒数的位置，将计算得出的倒数位置与target比较，若相等，则执行删除节点的操作，若不等，则继续向下计数。
Q1:问题在于自己想的过于简单了，因为无法知道链表的整个长度，所以这条路走不通
A1:其实整个链表的长度是可以知道的，可以遍历整个链表，进行计数。
但是最终的结果需要进行分类讨论，因为最后的节点的删除与中间节点的删除，过程有点不太一样。
还有最关键的一点是cur一定要指向当前要删除节点的前一个结点！！！
综上。利用这种方法，步骤繁琐，条件过多，不推荐
使用双指针思想会更便于操作
双指针法
定义fast指针和slow指针，指向dummyhead
首先让fast指针先走n+1步，然后fast与slow同时向后走，直到fast指向了NULL，此时slow指针指向了要删除的第n个节点的前一个节点
之所以要让fast走n+1步，而不是n步，是因为要使得slow指针指向要删除的节点的前一个节点。
- 时间复杂度: O(n)
- 空间复杂度: O(1)
/**
* 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* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyhead = new ListNode(0);
ListNode* fast = dummyhead;
ListNode* slow = dummyhead;
dummyhead->next = head;
// while(n--&&fast!=NULL)
// {
// fast = fast->next;
// }
// fast = fast->next;//在n很大，超出链表长度时,fast必然已经指向了null,fast = fast->next对空指针操作
n++;
while(n--&&fast!=NULL){
fast = fast->next;
}//此时fast走到了n+1的位置
//同时移动fast和slow，直到fast指向了NULL
while(fast!=NULL){
fast = fast->next;
slow = slow->next;
}
//当fast=NULL时，此时slow指向了要删节点的前一个结点
slow->next = slow->next->next;
// ListNode *tmp = slow->next; //C++释放内存的逻辑
// slow->next = tmp->next;
// delete tmp;
return dummyhead->next;
}
};题目3：面试题 02.07.链表相交
题目链接：链表相交
对题目的理解
找出两个单链表起始交点，若没有交点，返回NULL, 即求两个链表交点节点的指针，一定要是指针相等，不是数值相等
步骤：
i）求出两个链表的长度，并求出两个链表长度的差值，
ii）让curA移动到，和curB 末尾对齐的位置,此时，就可以比较curA和curB是否相同，
iii）如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。
- 时间复杂度：O(n + m) 求了A和B两个链表的长度，所以加起来m+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 *getIntersectionNode(ListNode *headA, ListNode *headB) {
//定义两个指针指向A,B链表的头节点
ListNode* curA = headA;
ListNode* curB = headB;
//求得两个链表的长度
int lenA = 0, lenB = 0;
while(curA!=NULL){
lenA++;
curA = curA->next;
}
while(curB!=NULL){
lenB++;
curB = curB->next;
}
//注意这里curA,curB已经移动到链表的最后一个节点处了，后续进行操作仍然需要从head处开始，所以将curA,curB移动到head
curA = headA;
curB = headB;
//求得两个链表长度的差值
//因为会出现lenA<lenB的情况，所以要使得A为最长链表，这样便于逻辑
if(lenB>lenA){
swap(lenA,lenB);
swap(curA,curB);
}
int dek = lenA - lenB;
//将最长链表A的指针curA移到与B的指针curB相同的位置
while(dek--){
curA = curA->next;//前面已经判断果curA!=NULL了，所以这里的循环就不需要再判断了
}
//同时移动curA和curB
while(curA!=NULL){
if(curA == curB){
return curA;
}
else {
curA =curA->next;
curB = curB->next;
}
}
return NULL;
}
};！！！！注意在求解完两个链表的长度之后，一定要将curA,curB重新移动到headA,headB处，进行后续的操作
还有就是求解两个链表的长度差时，一定要知道哪个链表长，这样才能顺利求长度差，所以使用swap函数，交换lenA与lenB的值，这样使得链表A永远是长度最长的那个链表，这样便于计算编程。
题目4：142 环形链表Ⅱ
题目链接：142. 环形链表 II - 力扣（LeetCode）
对题目的理解
返回链表开始入环的第一个节点，如果没有，则返回NULL；
pos表示链表尾接到链表中的位置（pos从0开始计）
拆解题目
- 判断链表是否环
- 如果有环，如何找到这个环的入口
i）判断链表是否有环，需要定义一个双指针，fast和slow，开始都指向head，令fast指针每次走两步（两个节点），slow指针每次走一步（一个节点），fast相对于slow每次只走一步（一个节点），那么如果有环的话，在环内，一定是fast追赶slow的过程中，fast会遇到slow，所以，fast一定会遇到slow ，且fast至少走一圈，才能实现追赶slow的情况，才会和slow相遇。
假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。
fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2；
相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。
slow等于x+y而不等于x+y+n(y+z)的原因：
将整个环形展平，在slow第一次到达环形入口时，fast位于环形内的某一位置，当slow走一圈时，fast所走路长定位slow的两倍，其fast相对slow走一步，那么fast定会和slow在slow走一圈之前（也就是fast走第一圈）相遇（红色虚线）
要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。
推演出x==z,那么再定义两个指针index1和index2，将index1放置在head，index2放置在fast和slow相遇的点，让index1与index2以相同的步数前进，那么index1和index2一定会在环形节点的入口相遇。
- 时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n
- 空间复杂度: O(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) {
//首先判断是否有环
//定义两个指针fast slow，判断是否会相遇
ListNode* fast = head;
ListNode* slow = head;
while(fast!=NULL&&fast->next!=NULL){ //由于fast一次走两步，所以还需要判断fast->next不为空
fast = fast->next->next;//fast一次走两步
slow = slow->next;//slow一次走一步
if(fast == slow){//快慢指针相遇
ListNode* index1 = head;
ListNode* index2 = fast;//等于slow也是一样的，因为在这个点相遇
while(index1!=index2){
index1 = index1->next;
index2 = index2->next;
}
return index1;
}
}
return NULL;
}
};
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
