代码随想录算法训练营第四天| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

接了个活，搞得我今天没赶上打卡，根本没时间写

 ListNode *nhead=new ListNode(0);
        nhead->next=head;

额外设置指针来遍历链表，以及暂存要改动的链表指针也是经常用的手段
先来说一下我最终犯得错误

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *nhead=new ListNode(0);
        nhead->next=head;
        ListNode *cur=nhead;
        while(cur->next!=nullptr&&cur->next->next!=nullptr){
            //先写循环体
            //什么时候停止循环：当要交换的结点其中之一为空，不需要担心用来做指针的为空，它每次都是指向的已经交换好的结点或者是头节点。
            ListNode *tmp=cur->next;
            ListNode *tmp1=cur->next->next->next;
            cur->next=cur->next->next;
            //变化要能反应过来
            cur->next->next=tmp;
            cur->next->next->next=tmp1;
            cur=cur->next->next;//cur指向下一组要交换的相邻结点的前一个结点
        }
        return head;
    }
};

return了head 这个head 初始可就是1，随着交换，1的位置也不再是开头，变到了例子中的第二位。
所以就有了以下结果
最初那个没变的是虚拟头节点，一开始cur指向虚拟头节点，然后它让虚拟头节点的指向了2,就是交换后的第一个结点，交换完之后，头节点往后走俩个结点指向新一轮要交换的相邻节点的头节点。
于是，最终没变的是虚拟头节点，还是在最开始。
返回新链表中第一个结点，即头节点所指向的结点。

自己在二刷的时候后遇到一个问题就是，某个结点指向下一个结点，指的是要对该结点的next指针赋值，而不是直接让该结点

还好周日休息，要不然我就赶不上大队伍了，每天的题我得敲半天多

还是双指针，倒数第几个的话，得有一个快指针先走到最后，然后慢指针刚好指向要删除的结点的前一个结点，然后让慢指针的结点指向快指针的结点
释放所删除的结点的空间

第一次想的错误代码,我没采取n+1,我就让快慢指针间差n个结点，天真的我以为，q会一直是要删除结点的后一个结点。这傻的。。。
快指针的作用是走到链表尾，让慢指针走到要被删除的结点的前一位。
我让快指针走到了最后一个结点，（这个也是可以的）此时慢指针刚好走到了被删除的前一个结点，然后，应让慢指针的结点指向其下一个的下一个结点（这个结点不一定是快指针指向的结点！！），特殊的要想到的情况就是只有一个元素而且，删除该元素那么该链表就会为空了。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *nhead=new ListNode(0);//设置一个头指针。
        nhead->next=head;
        ListNode *p=nhead;
        ListNode *q=nhead;
        //n=n+1;
        while(n--){。
            q=q->next;
        }
        while(q->next!=NULL){
            q=q->next;
            p=p->next;
        }
        ListNode *t=p->next;
        p->next=q;//错误！！！
        delete(t);
        return nhead->next;
        
    }
};

//正确的代码
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *nhead=new ListNode(0);//设置一个头指针。
        nhead->next=head;
        ListNode *p=nhead;
        ListNode *q=nhead;
        //n=n+1;
        while(n--){
            q=q->next;
        }
        while(q->next!=NULL){
            q=q->next;
            p=p->next;
        }
        ListNode *t=p->next;
        p->next=p->next->next;
        delete(t);
        return nhead->next;
        
    }
};

这道题408上考过，应该是确定这个共同结点所指向的下一个节点相同吧。
但是结点的值也要相同，所以是cur1==cur2才是判断公共节点的方法

卡哥的思路是，先求出两个链表的长度，然后让指针从相同的位置逐个对比，直到走向链表末尾。

这里面比较有技巧的就是保持变量A与相应指针始终指向最长的那个，然后代码上只让最长的指针先走。，走到与另一指针相同的位置的时候再比较指针是否相同

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
            ListNode *p= headA;
            ListNode *q= headB;
            int A=0,B=0;
            //统计每个链表长度
            while(p!=NULL){
                A++;
                p=p->next;
            }
            while(q!=NULL){
                B++;
                q=q->next;
            }
            //让两个指针重新归位
            p=headA;
            q=headB;
            //
            if(A<B){
                swap(A,B);
                //遇到了一个问题就是AB换了指针还没换，链表的长度还是原来的状态              
                swap(p,q);//这样就能让p默认为最长的链表，A代表最长的长度。
                }
            int n=A-B;
            while(n--){p=p->next;}
            while(p!=NULL&&p!=q){
                p=p->next;
                q=q->next;
            }
            if(p!=NULL)return p;
            else return NULL;
            
            

    }
};

有无环的判断应该为是否从一个结点开始遍历还能遍历到自己
卡哥建议用快慢指针法，
如果无环，慢指针是不能追上快指针，即是不能与快指针相遇的。
如果有环，快慢指针是会相遇的。

那有同学又说了，为什么fast不能跳过去呢？ 在刚刚已经说过一次了，fast相对于slow是一次移动一个节点，所以不可能跳过去。fast的速度比slow快一个结点。
x=(n-1)(y+z)+z
当快慢指针遇到的时候，快慢指针所走的路程可以得出以上等式，x即为头节点到环的入口的距离，恰好等于快指针绕（n-1）圈再多走从相遇点到入口的距离。

一开始在循环上加了未相遇的约束条件，但是这样不对
一位群友指出了我的错误，一开始在初始化快慢指针的时候，这俩指针是相等的根本不会进入循环。。。谨防初始化相同

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *f=head;
        ListNode *s=head;
        while(s!=f&&f!=NULL&&f->next!=NULL)//f下一个也不应该为空，因为它一下走俩，有可能这俩直接为空了。。。
        {
            s=s->next;
            f=f->next->next;
        }
        if(s==f){//这个if别忘了，可别直接赋两个指针。
        ListNode*p=head;
        ListNode*q=f;
        while(p!=q){
            p=p->next;
            q=q->next;
        }return q;}
        
        return NULL;
    }
};

循环的范围应在return NULL 之前。万一f为空的同时，快慢指针相遇了呢？

我还是不理解呜呜呜呜呜

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *f=head;
        ListNode *s=head;
        while(f!=NULL&&f->next!=NULL)//f下一个也不应该为空，因为它一下走俩
        {
            s=s->next;
            f=f->next->next;
        
        if(s==f){//这个if别忘了，可别直接赋两个指针。
        ListNode*p=head;
        ListNode*q=f;
        while(p!=q){
            p=p->next;
            q=q->next;
        }return q;}
        }
        return NULL;
    }
};