链表经典题目（1）

前面我们已经讲过了单链表和双向链表的基本用法，如果你已经掌握，那么就需要做一些题目进行巩固，这篇文章我来梳理一下最近学过的几道经典题目，我感觉意义很大。

1.判断带环问题

题目：判断链表是否带环

基本解法：

这道题的思路很简单，显然是一个单链表，只需要用快慢指针的思想进行解答，慢指针一次走一步，快指针一次走两步，用一个while循环，若带环则当快指针等于慢指针的时候即返回true，若不带环，则快指针走到链表末尾，返回false。

bool hasCycle(struct ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return false;
    }
    struct ListNode* slow = head;
    struct ListNode* fast = head->next;
    while (slow != fast) {
        if (fast == NULL || fast->next == NULL) {
            return false;
        }
        slow = slow->next;
        fast = fast->next->next;
    }
    return true;
}

深入思考：

这道题从根本上来说，就是追击问题，即fast指针追上slow指针，即带环。

那么就引申出几个问题，若这些问题能够得到解决，那么你的逻辑和算法能力都会得到提升

1.为什么一定会相遇，有可能会错过或永远追不上吗？

2.slow指针一次走一步，fast指针一次走3步，4步，n步，结论会发生变化吗？

1.

这是初始时，带环链表的结构图

当slow进环后，fast指针开始追击slow

我们假设在slow进环时，fast和slow的距离为L，由于fast的速度是slow的二倍，则每移动一次，二者的距离便-1，变为L-1，直到L = 0时fast追到slow，即可追上，也代表链表带环。

2.第二个问题才是最关键的

我们这里只介绍fast走一次三步的情况

若fast一次走三步，则fast和slow的距离一次减少2，则要分为两种情况，一种是L为奇数，一种为L为偶数，思维图如下：

总结一下：

1.L若是偶数，则第一轮就能追上

2.L是奇数，第一轮追击就会错过，距离变成C-1

        a.若C-1为偶数，下一轮就追上了

        b.若C-1为奇数，那么就无法追上

        即        L为奇数同时C为偶数时，就永远追不上                        （*）

我们下面来证明一下是否存在这类情况

slow进环时，fast和slow的距离为L

slow走过的距离为S

slow进环时，fast已转过X圈

fast是速度是slow的3倍，则走过的距离也是slow的三倍

有等式 3*S = S+X*C-L

化简得2*L = (X+1)*C-L

由于2*L是偶数，则（X+1）*C和L必须同时是奇数或同时是偶数时，等式才成立

此结论与前面的（*）式矛盾，则L为奇数同时C为偶数的条件不可能出现

所以综上所述，fast指针一定能追上slow指针，L是偶数第一轮就追上了，L是奇数第一轮追不上，C-1是偶数第二轮就追上了。

思路还算清晰，大家好好梳理一下，就能理解，这个对逻辑能力有很大提升。

2.判断带环节点问题

题目：环型链表Ⅱ

判断是否带环，直接用第一题的函数即可解答，主要解释如何找出入环节点

思路：

直接说结论：先用快慢指针找到相交节点，肯定在环中，然后创建两个指针一个从链表头节点走，一个从相交节点走，两个指针相交位置即为入环节点。

证明：

设环的长度为C，头节点到入环点的距离为L，Meet相交点距入环点为N。

slow的路程为L+N

fast的路程为L+X*C+N

2*（L+N）= L+x*C+N

L+N=x*C

L=x*c-N

L=(x-1)*C+C-N

这个等式即结论，即入环点的距离是距相交点和距头节点相等

解答代码如下

struct ListNode* detectCycle(struct ListNode* head) {
    struct ListNode *slow = head, *fast = head;
    while (fast != NULL) {
        slow = slow->next;
        if (fast->next == NULL) {
            return NULL;
        }
        fast = fast->next->next;
        if (fast == slow) {
            struct ListNode* ptr = head;
            while (ptr != slow) {
                ptr = ptr->next;
                slow = slow->next;
            }
            return ptr;
        }
    }
    return NULL;
}

第二个方法：

第二个方法有点暴力，要破坏链表的环结构，即在Meet的位置直接断开，使其next指向空，那么这个问题就变成了之前讲过的寻找链表的公共节点的问题，即这个问题：寻找链表的公共节点，找到第一个节点，即为所求的入环点。

模型图如上所示。

3.复杂链表的拷贝

题目：随机链表的复制

这道题目，主要的考点是有两个节点，next节点并不难拷贝，但是关键在于random指针的拷贝，如果我们没有思路的话没有办法找到新节点的位置，就无法解决问题。

思路：

1.我们可以将链表记录在数组中，在用循环的思路，依次找出random指向的节点，在进行修改，这个思路可以解决问题，但是时间复杂度在O（n^2）

2.将拷贝的节点插入到原节点的后面，这样拷贝节点和原节点就建立了一种关联关系

在图中我们可以看到，我们将原节点的next指向拷贝节点再将拷贝节点指向原节点的next，这样下来就能轻松的建立random的联系，我们可以发现拷贝节点的random节点指向，即原节点random指向的next节点，这样就完成了random的拷贝

（上面这段话有点绕，大家可以看着图好好琢磨一下，重点在于如何将random节点用原节点和拷贝节点关联起来）

这个题的思路十分奇妙，如果你能够在明白思路后，自己独立的将这道题做出来，就说明你的单链表基本用法已经掌握的很好了。

有了思路，这道题就迎刃而解了，代码只是对单链表基本用法的考察

​
class Solution {
public:
    Node* copyRandomList(Node* head) {
      Node* cur = head;
    //拷贝节点插入原节点后面
      while(cur)
      {
        Node* copy = (Node*)malloc(sizeof(Node));
        copy->val = cur->val;
        copy->next = cur->next;
        cur->next = copy;
        cur = copy->next;
      }  
      cur = head;
      while(cur)
      {
        Node* copy = cur->next;
        if(cur->random==NULL)
        {
            copy->random = NULL;
        }
        else
        {
            copy->random = cur->random->next;
        }
        cur = copy->next;
      }
        cur = head;
    //把拷贝节点取下来尾插成为新链表，然后顺手恢复一下啊原链表   
        Node* copyhead = NULL;
        Node* copytail = NULL;
        while(cur)
        {
            Node* copy = cur->next;
            Node* next = copy->next;
            if(copyhead == NULL)
            {
                copyhead = copytail = copy;
            }
            else{
                copytail->next = copy;
                copytail = copytail->next;
            }
            cur->next = next;
            cur =  next;

        }
        return copyhead;
      }
};

​

总结：

第一道题，希望大家理解快慢指针追击的条件思路

第二道题，希望大家理解为什么相遇点和头节点距离入环点相等

第三道题，希望大家理解将拷贝节点插入到原节点后的解题思路

以上就是三道经典链表OJ题的解法与深度拓展，希望大家能通过这篇文章有所收获，在逻辑思维能力和代码能力有所进步。