数据结构——单链表OJ题（下）

linynn_

于 2024-07-25 19:28:17 发布

阅读量595

点赞数 22

文章标签：数据结构 c语言链表

本文链接：https://blog.csdn.net/2301_81888634/article/details/140690202

版权

一、链表的回文结构

思路一：数组法

将链表中结点的数据存储在数组中，创建两个指针分别从左右两边遍历并比较，如果左右对称则说明是回文结构。

（1）注意

①为什么要创建数组存储数据？因为链表的结点不是连续的，不能进行逆向访问；

②从左右两端进行遍历时，需满足left<right的条件；

③该方法只适用于链表长度小于等于900的条件下，因为数组的长度最大为900。

（2）解题

typedef struct ListNode ListNode;
bool chkPalindrome(ListNode* A) 
    {
        //创建数组存储数据
        int arr[900] = {0};
        //数据的个数为i
        int i = 0;
        ListNode* pcur = A;
        //遍历链表，将数据存储在数组中
        while(pcur)
        {
            arr[i++] = pcur->val;
            pcur = pcur->next;
        }
        int left = 0;
        int right = i - 1;
        while(left < right)
        {
            //若有不相等，说明不是回文结构
            if(arr[left] != arr[right])
            {
                return false;
            }
            left++;
            right--;
        }
        //跳出循环，说明left和right指向的数据一直相等，即回文结构
        return true;
        
    }

思路二：反转链表法

使用快慢指针法找到原链表的中间结点，将中间结点之后的链表进行反转，最后将原链表的前半段与新链表存储的数据进行比较。

（1）注意

①寻找中间结点和反转链表在上节已练习，可将它们封装成两个函数；

②由于原链表的长度大于新链表（反转后的），因此循环结束的判定条件是p2==NULL。

（2）解题

class PalindromeList {
    //寻找中间结点的函数
    ListNode* midNode(ListNode* head)
    {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast && fast->next)
        {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
    //将链表进行反转的函数
    ListNode* reverse(ListNode* head)
    {
        ListNode* n1, * n2 , *n3;
        n1 = NULL;
        n2 = head;
        n3 = head->next;
        while(n2)
        {
            n2->next = n1;
            n1 = n2;
            n2 = n3;
            if(n3)
            {
                n3 = n3->next;
            }
        }
        return n1;
    }
public:
    bool chkPalindrome(ListNode* A) 
    {
        //原链表的中间结点
        ListNode* mid = midNode(A);
        //将中间结点之后的链表进行反转
        ListNode* p2 = reverse(mid);
        ListNode* p1 = A;
        //遍历两个链表的值，比较是否相等
        while(p2)
        {
            //存在不相等的，说明不是回文结构
            if(p1->val != p2->val)
            {
                return false;
            }
            p1 = p1->next;
            p2 = p2->next;
        }
        //跳出循环，说明left和right指向的数据都相等，即为回文结构
        return true;
    }
};

二、相交链表

（1）思路：快慢指针

首先找到两个链表长度的差值k，创建两个指针指向头结点，快指针先走k步，接着快慢指针一起走，若快慢指针指向同一个结点，则说明该结点为相交结点。

（2）注意

①计算差值时无法确定两个长度谁大谁小，可使用abs()绝对值函数；

②通过比较两个长度的大小来确定快指针指向哪个链表的头结点；

③判断快慢指针指向的结点是否相同，而非结点指向的数据！！

（3）解题

typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    //计算两个链表的长度
    int len1 = 0;
    int len2 = 0;
    ListNode* pcur = headA;
    while(pcur)
    {
        pcur = pcur->next;
        len1++;
    }
    pcur = headB;
    while(pcur)
    {
        pcur = pcur->next;
        len2++;
    }
    //两个链表长度的差值k
    int k = abs(len1 - len2);
    //快指针指向长链表的头结点
    ListNode* fast = headA;
    ListNode* slow = headB;
    if(len1 < len2)
    {
        fast = headB;
        slow = headA;
    }
    //快指针先走k步
    while(k--)
    {
        fast = fast->next;
    }
    //比较两个指针指向的结点是否相同
    while(fast && slow)
    {
        if(fast == slow)
        {
            return fast;
        }
        fast = fast->next;
        slow = slow->next;
    }
    return NULL;
}

三、环形链表1

（1）思路：快慢指针

创建快慢指针并指向头结点，快指针一次经过两个结点，慢指针一次经过一个结点，若最终快指针与慢指针相遇，则说明该链表是环形链表。

（2）解释

①为什么在起点相同的情况下，快指针走两步，慢指针走一步，两者可以相遇，会不会遇不上？

假设此时fast进入环，slow走完入环前的距离准备入环，此时它们之间的距离为N。在接下来的追逐中，它们每追击（变换位置）一次，两者之间的距离缩小一步，直至相遇。（参考下图理解）

②如果慢指针一次走一步，快指针一次走3、4、5...n步，快慢指针还能再相遇吗？

可以！以快指针一次走3步为例：

slow入环后，slow和fast在环内进行追逐，假设两者之间的距离为N，那么在之后的过程中，每追逐一次两者之间的距离就缩小两步。

若N为偶数，最终距离可缩小为0，即相遇；若N为奇数，假设环的长度为C，会出现套圈情况（即slow走在fast前面），此时两者之间的长度为C-1。

此时需要讨论C-1是奇数还是偶数，若C-1为偶数，则可以相遇。若C-1为奇数，两者还会错过，继续套圈，那么fast和slow还会再相遇吗？

假设slow走完入环前的距离L，刚准备入环；fast在环里走了x圈，且此时fast和slow之间的距离为N，那么两者走过的长度分别为：slow : L fast : L + xC + (C - N)。又因为fast的速度是slow的3倍，因此3L = L + xC + (C - N)，化简得：2L = (x + 1)C - N

上述条件中：N为奇数，C为偶数。因为：偶数= 偶数-偶数，偶数=奇数-奇数。那么（x+1）C为奇数时，会相遇。因此，如果慢指针一次走一步，快指针一次走3步，快慢指针还能再相遇。

同理可得其它步数的情况下也可相遇。

（3）注意

①循环结束的判定条件是fast && fast->next：若fast为空则说明不是环形链表；

②不能写成fast->next && fast，要先判断fast，因为如果fast为空，就不能取next；

③虽然证明了快指针不论走多少步都可以满足在带环链表中相遇，但是在编写代码的时候会有额外的步骤引入，涉及到快慢指针的算法题中通常习惯使用慢指针走一步、快指针走两步的方式。

（4）解题

①快指针走两步

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

② 快指针走三步

typedef struct ListNode ListNode;
bool hasCycle(struct ListNode *head) 
{
    ListNode* fast = head;
    ListNode* slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        //快指针一次走三步
        int n = 3;
        while(n--)
        {
            if(fast->next)
            {
                fast = fast->next;
            }
            else 
            {
                return false;
            }
        }
        if(fast == slow)
        {
            return true;
        }
    }
    return false;
}

四、环形链表2

（1）思路：快慢指针

创建两个指针，一个从链表的头结点开始遍历链表，另一个从快慢指针的（判断是否为环形链表的）相遇点开始绕环运行，两个指针都是一次走一步，最终会在入口点的位置相遇。

（2）解释

①为什么相遇点和头结点到入环结点的距离是相等的？

假设环的长度为R，入环之前的距离为L，入环节点到相遇点的距离为X，那么相遇点到入环结点之间的距离为R-X。

在判环时（此时在相遇点），快慢指针走的路程为：slow : L+X fast :L+nR+X（其中n≥1）。

由于判环时，快指针一次走两步，慢指针一次走一步，则快指针的路程时慢指针的两倍。且慢指针入环之后，快指针一定会在一圈之内追上慢指针（因为慢指针入环之后，两者之间的距离最大为环的长度，而每追击一次，两者之间的距离缩短一步，因此在一圈之内，快指针一定能追上慢指针）。

那么：2*（L+X）= L+nR+X，化简为：L = nR - X，即L = (n -1)R+(R-X)。在极端情况下：假设n=1，则：L=R-X，即头结点到和相遇点到入环结点之间的距离相等。

（3）注意

①fast && fast->next位置的注意事项同上。

（4）解题

typedef struct ListNode ListNode;
struct ListNode *detectCycle(struct ListNode *head) 
{
    ListNode *fast = head;
    ListNode *slow = head;
    while(fast && fast->next)
    {
        //fast一次走两步，slow一次走一步
        fast = fast->next->next;
        slow = slow->next;
        if(fast == slow)
        {
            ListNode* pcur = head;
            //判断两者何时相遇
            while(pcur != slow)
            {
            pcur = pcur->next;
            slow = slow->next;
            }
            return slow;
        }
    }
    //链表不带环
    return NULL;
}

五、随机链表的复制

（1）思路

在原链表的基础上继续复制链表，置random指针（copy->random = pcur->random->next），最后将复制链表和原链表断开，得到复制链表。

（2）解题

typedef struct Node Node;
Node* buyNode(int x) {
    Node* newnode = (Node*)malloc(sizeof(Node));
    newnode->val = x;
    newnode->next = newnode->random = NULL;
    return newnode;
}
void AddNode(Node* phead) {
    Node* pcur = phead;
    while (pcur) 
    {
        // 存储pcur的下一个结点
        Node* Next = pcur->next;
        // 创建新结点，尾插到pcur
        Node* newnode = buyNode(pcur->val);
        pcur->next = newnode;
        newnode->next = Next;
        pcur = Next;
    }
}
struct Node* copyRandomList(struct Node* head) {
    if(head == NULL)
    {
        return NULL;
    }
    // 1.在原链表上复制结点
    AddNode(head);
    // 2.置random
    Node* pcur = head;
    while (pcur) 
    {
        Node* copy = pcur->next;
        if (pcur->random != NULL) 
        {
            copy->random = pcur->random->next;
        }
        pcur = copy->next;
    }
    // 3.断开链表
    pcur = head;
    Node *newHead, *newTail;
    newHead = newTail = pcur->next;
    while (pcur->next->next) 
    {
        pcur = pcur->next->next;
        newTail->next = pcur->next;
        newTail = newTail->next;
    }
    return newHead;
}