C学习（数据结构）--＞单链表习题

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

题二：环形链表 II

https://leetcode.cn/problems/linked-list-cycle-ii/description/

思路：

让一个指针从头结点开始遍历链表，同时让一个指针从判定该链表为环形链表的相遇点开始绕环运行，两个指针都是每次只走一步，最终一定会在入口点相遇

思考：为什么？

设头结点为 H ，入环点为 E ，H 到 M 的距离为 L，快慢指针相遇点为 M ，E 到 M 的距离为 X ，环的长度为 R 则

则快慢指针相遇时，快（fast）慢（slow）指针相遇时，假设快指针已经绕环走了 n 圈，则，两指针走过的路程

fast ：L+X+n*R
slow：L+X

取快指针一次两步，慢指针一次一步，可得方程式

L+X+n*R = L+X

化简得 L = n*R-X；

即 L= (n -1)*R+(R-X)，n取1，2，3，4......

当n = 1时，L = R-X，则

则让一个指针从头结点开始遍历链表，同时让一个指针从判定该链表为环形链表的相遇点开始绕环运行，两个指针都是每次只走一步，最终一定会在入口点相遇、

代码：

cpp 复制代码

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

二、随机链表的复制

https://leetcode.cn/problems/copy-list-with-random-pointer/description/

思路：

步骤一：

遍历原链表根据结点保存的数据，申请并复制到新的结点，并且插入到该节点后。

步骤二：新结点的随机指向结点

赋值：新结点的随机指向结点 = 原链表结点的随机指向结点的下一个结点

步骤三：链接新结点

代码：

cpp 复制代码

/**
 * Definition for a Node.
 * struct Node {
 *     int val;
 *     struct Node *next;
 *     struct Node *random;
 * };
 */
typedef struct Node Node;
//申请新结点
Node* BuyNode(int val)
{
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = val;
    newNode->next = NULL;
    newNode->random = NULL;
    return newNode;
}
//插入原链表
void PushNode(Node* pNode)
{
    Node* pcur = pNode;
    while(pcur)
    {
        Node* pNext = pcur->next;
        Node* newNode = BuyNode(pcur->val);
        newNode->next = pNext;
        pcur->next = newNode;
        pcur = pNext;
    }
}
struct Node* copyRandomList(struct Node* head) {
    if(head == NULL)
    {
        return head;
    }
    //插入原链表
    PushNode(head);
    //拷贝random
    Node* pcur = head;
    while(pcur)
    {
        Node* pcpy = pcur->next;
        if(pcur->random != NULL)
        {
            pcpy->random = pcur->random->next;
        }
        pcur = pcpy->next;
    }
    //链接新链表
    Node *newHead,*newTail;
    pcur = head;
    newHead = newTail = pcur->next;
    while(pcur->next->next)
    {
        pcur = pcur->next->next;
        newTail->next = pcur->next;
        newTail = pcur->next;
    } 
    return newHead;
}