数据结构 day4：两两交换链表结点、环形链表II、链表相交、删除链表的倒数第N个结点

day 4 两两交换链表中的结点 环形链表II 链表相交 删除链表的倒数第N个结点

两两交换链表中的结点

Problem: 24. 两两交换链表中的节点

思路

这种题属于动链表顺序的题，一旦动链表顺序，必定要用tmp。难点在与如何找到正确循环步骤：

如果是这种需要变化的多的情况：如图：需要cur->2; 2->1; 1->3这三步其实完全没有任何的关系。cur->2，导致必须用tmp保存1；2->1，导致必须用tmp保存3；1->3，导致必须用tmp保存2。
也就是说最麻烦，最无脑的方法就是动几根线，就用几个tmp。
但是这里有优化：就是先用tmp，断一根用一根，不要都断了。把tmp充分利用
比如图中cur->2，断了cur->1这根。所以tmp就是1。然后马上看1有没有线。可以看到1->3，马上连1->3，这样2->3这根断了也无所谓了。因为tmp能连上。最后可以用2->tmp。这样就只用了一个tmp。

注意！

这个题和翻转链表不太一样，反转链表可以看成是把旧的头删，然后插到新的里。这个不是。

解题方法

思路就是上面的思路。但是边界问题这种交换的链表问题。使用虚拟头结点也很好解决。while中的条件就是：p->next && p->next->next && … 这个取决于你要交换的个数。比如你交换的是两个，那就是p->next && p->next->next。如果交换的是一个。那就p->next。

Code

/**
 * 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 *vir = new ListNode(0);
        vir->next = head;
        ListNode *p = vir;
        while(p->next && p->next->next)
        {
            ListNode *tmp = p->next->next;

            p->next->next = tmp->next;
            tmp->next = p->next;
            p->next = tmp;
            
            p = tmp->next;
        }
        return vir->next;
    }
};

环形链表II

Problem: 142. 环形链表 II

思路

第一眼的思路是一个一个节点的判断，但是暴力一定不是最优解，一般这种题都是双指针问题。想来想去想到了快指针一定会和慢指针相遇的。但是将第一次相遇的点误以为了要求的点。下图为讲解方便，分别定义从左到右三个结点为123号结点。

也就是将3号结点当成目的节点。但其实2号结点为目的节点。
其实这个题是在求x。
慢指针走的路程：x+y
快指针走的路程：x+y+z+y
但是快指针走的速度是慢指针的两倍，所以得到：2 *（x+y） = x+y+z+y
解得：z = x
所以很巧，慢指针不要动，然后让一个新指针（为了方便用快指针即可，但是这里快指针就不能快了，它需要和，慢指针同速），然后同时走，他两再次遇到就会在2号点遇到了。

解题方法

思路上面已经写得很清楚了，操作起来不是很复杂，但是！
我下面使用了do while ，为什么不是while do呢，来解释一下：
do while 和 while do其实只有刚开始是有区别的。如果一个题，do while和while do有区别。那么马上要检查：第一次的结点是否应该在判断里。
我们这道题的目的是判断它们运动起来以后，结点是否相等，第一个结点我们需要管吗？不需要的。所以这里就要用do while 要让它先动一次。
但是平常的时候，比如遍历，我们的第一个结点在不在我们想检查的范围里呢，当然在，所以就是while do。

Code

/**
 * 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) {
        ListNode *vir1 = new ListNode(0);
        vir1->next = head;
        ListNode *slow = vir1;
        ListNode *fast = vir1;
        do
        {
            if(fast->next == NULL || fast->next->next == NULL) return NULL;
            fast = fast->next->next;
            slow = slow->next;
        }
        while(slow->next != fast->next);
        fast = vir1;
        while(fast->next != slow->next)
        {
            fast = fast->next;
            slow = slow ->next;
        }
        return slow->next;
    }
};

链表相交

Problem: 面试题 02.07. 链表相交

思路

只要有相同的路，那么我走完我的再走你的，和你走完你的再走我的，就一定能遇到，这个想法特别的优美。
假如A:不同的路有3个，B：不同的路有5个。他俩相同的路有6个。那么他们一起走的话，3+6+5 = 5+6+3。所以一定会遇到。

解题方法

根据上面的描述，实现这个是一个很简单的事情。注意一点是。我这里用了虚拟头结点。然后要到了末尾转变成另一个链表的时候，想的是p2->next = virb,这里犯了大忌。接下来说一下为什么：
如果你只想遍历这个链表，那么绝对不要让p->next去等于什么，一旦涉及到p->next = 什么，就会改变链表的形态。所以是p = p->next,或者根据需求去p = 什么什么。
但如果你想改变链表的形态，比如增删之类的操作，那么你一定会动p->next。只有next是维持链表状态的东西，所以一定要注意。

Code

/**
 * 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) {
        ListNode *vira = new ListNode(0);
        vira->next = headA;
        ListNode *virb = new ListNode(0);
        virb->next = headB;
        ListNode *p1 = vira;
        ListNode *p2 = virb;
        while(p1->next != p2->next)
        {
            if(p1->next) p1 = p1->next;
            else p1 = virb;
            if(p2->next) p2 = p2->next; 
            else p2 = vira;
        }

        return p1->next;
    }
};

删除链表的倒数第N个结点

Problem: 19. 删除链表的倒数第 N 个结点

思路

使用双指针方法，让快指针先走n个结点，然后让快指针和慢指针一起走，当快指针走完的时候，慢指针就是那个倒数n的那个结点。

解题方法

这个有了思路后很简单，一遍过。要注意的点是，使用虚拟头结点后，p->next才是目标点。所以要时时刻刻盯着next。

Code

/**
 * 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 *vir = new ListNode(0);
        vir->next = head;
        ListNode *fast = vir;
        ListNode *slow = vir;
        while(n)
        {
            fast = fast->next;
            n--;
        }
        while(fast->next)
        {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode *tmp = slow->next;
        slow->next = tmp->next;
        delete(tmp);
        tmp = NULL;
        return vir->next;

    }
};