链表经典OJ题（详细过程）

1.随机链表的复制

本题是一道经典的链表题，当我们学习完链表可以拿这道题来检验一下我们的学习成果！

接下来我们来看一下这道题，结合用例我们来理解一下：

        大致的题意就是要我们建立一个新的链表，复制原链表 ，每个新节点的值和原节点的值相同，新节点的指针也都指向复制链表的新节点！

1.1大体思路

  首先我们可以看出原链表中的random指针的指向是不固定的，可以指向NULL，可以指向任意位置，这也是本题最难解决的问题，但是也有一种巧妙的解决办法，就是把新节点插入到原链表每个节点的后面，这样做是为了拷贝节点和原链表建立关联关系。

1.把新节点插入到原链表每个节点的后面

2.控制random

3.将拷贝节点取下来尾插到新的链表中

接下来让我们一一实现！

1.2把新节点插入到原链表每个节点的后面

我们先来画图分析一下：

我们想要得到这样的一个链表， 那我们就可以用malloc申请新节点，写一个循环！

这样我们就把新节点插入到了链表的每一个节点后面

1.3 控制random

  当我们把新节点插入到链表的每一个节点后面，这样拷贝节点就和原链表建立了联系，原链表的random怎么指，那么我们新节点的random就这么指，也就是新节点的random指向等于新节点random指向的下一个节点！

1.4将拷贝节点取下来尾插到新的链表中

这一部就很简单了，就是将我们拷贝的节点尾插到新链表中，我们学过单链表的尾插，思想和单链表尾插一样，不懂的可以看一下我的单链表博客！

1.5整体代码 

/**
 * Definition for a Node.
 * struct Node {
 *     int val;
 *     struct Node *next;
 *     struct Node *random;
 * };
 */

struct Node* copyRandomList(struct Node* head) {
	//1.创建新节点
    struct Node* cur = head;
    while(cur)
    {
        struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
        copy->val = cur->val;
        copy->next = cur->next;
        cur->next = copy;

        cur = copy->next;
    }
    

    //2.修改random
    cur = head;
    while(cur)
    {
        struct Node* copy = cur->next;
        if(cur->random == NULL)
        {
            copy->random = NULL;
        }
        else
        {
            copy->random = cur->random->next;
        }
        cur = copy->next;
    }

    

    //3.将链表分开
    cur = head;
    struct Node* copyhead = NULL, *copytail = NULL;
    while(cur)
    {
        struct Node* copy = cur->next;
        struct Node* next = copy->next;
        if(copytail == NULL)
        {
            copyhead = copytail = copy;
        }
        else
        {
            copytail->next = copy;
            copytail = copytail->next;
        }
        cur->next = next;
        cur = next;
    }
    return copyhead;
}

2.环形链表

这道题就是判断链表是否带环，我们可以使用快慢指针来解这道题！就是创立两个指针，慢指针一次走一步，快指针一次走两步！当快指针等于慢指针证明带环！

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool hasCycle(struct ListNode *head) {
    struct ListNode* solw = head;
    struct ListNode* fast = head;
    while(fast && fast->next)
    {
        solw = solw->next;
        fast = fast->next->next;
        if(solw == fast)
        {
            return true;
        }
        
    }
    return false;
}

对于这道题，还有一些额外的思考

2.1额外的思考

1.为什么会相遇，会不会错过，会不会永远追不上 ？

2.solw一次走1步，fast一次走3步，4步，是否会追不上？如何证明

我们首先来解决第一个：

这个很好证明，因为每次追击距离-1，到0的时候追到相遇！

第二个问题fast一次走3步，一定可以追上

 总结一下：

得出结论一定可以追上，我们也可以进行反证。N是奇数，C是偶数，第一轮追不上，下一轮追到，或者N和C都是偶数，那么第一轮就追到！

3.环形链表 II 

通读题目，就是要找环形链表的入口点！

3.1大体思路：

1. 创立快慢指针，当慢指针等于快指针

2.再newhead创立一个指针从头开始走，创立一个meet指针从slow和fast相遇的地方走

3.当从newhead指针和meet指针相遇就是环形链表的入口

3.2详细分析

3.3整体代码 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
        {
            struct ListNode* newhead = head;
            struct ListNode* meet = slow;
            while(meet != newhead)
            {
                meet = meet->next;
                newhead = newhead->next;
            }
            return meet;
        }
    }  
    return NULL;
}

总结：

第一题主要是链表的多方面考察，后面的两个题虽然代码比较简单，但是并不容易想到，要有一定的数理思想，可能不容易想到！