链表算法篇——链接彼岸，流离节点的相遇之诗(下）

news2025/1/6 19:04:25

文章目录

前言
第一章：重排链表
- 1.1 题目链接：https://leetcode.cn/problems/reorder-list/description/
- 1.2 题目分析：
- 1.3 思路讲解：
- 1.4 代码实现：
第二章：合并K个升序链表
- 2.1 题目链接：https://leetcode.cn/problems/merge-k-sorted-lists/description/
- 2.2 题目分析：
- 2.3 思路讲解：
- 2.4 代码实现：
第三章：K个一组翻转链表
- 3.1 题目链接：https://leetcode.cn/problems/reverse-nodes-in-k-group/description/
- 3.2 题目分析：
- 3.3 思路讲解：
- 3.4 代码实现：
第四章：现实世界中的链表——灵活性的代言人
第五章：链表的优雅与局限
尾声：链表的哲学——从离散到连贯

前言

上篇我们介绍了链表算法的相关概念，并结合基础题目加以讲解。本篇将通过三道进阶题目，进一步深化对于链表算法的掌握运用。

第一章：重排链表

1.1 题目链接：https://leetcode.cn/problems/reorder-list/description/

1.2 题目分析：

题目所要求的重组即为将后半部分链表逆序，之后逐个加入到前半部分链表中。

1.3 思路讲解：

既然后半部分需要逆序，那么我们首先需要找到中间结点

逆序时直接采用头插法可大大简化步骤

查找中间节点时，假设节点总数为奇数个，那么即为正中间的节点
若节点总数为偶数个，则可采取靠右的中间节点，该中点的下一个节点开始即为后半部分需要重排的链表

此时3为中间结点，重排结果如下：

1.4 代码实现：

class Solution {
public:
    void reorderList(ListNode* head) {
        ListNode* newhead=new ListNode(0);//哨兵位
        newhead->next=head;
        ListNode* slow=head,*fast=head;
        //查找中间节点
        while(fast&&fast->next)
        {
            slow=slow->next;
            fast=fast->next->next;
        }
        ListNode* cur1=head,*cur2=slow->next;//前后两部分链表头
        slow->next=nullptr;//断开两部分链接
        //将后半部分链表逆序
        ListNode* head2=new ListNode(0);
        while(cur2)
        {
            ListNode* next=cur2->next;
            cur2->next=head2->next;
            head2->next=cur2;
            cur2=next;
        }
        cur2=head2->next;
        ListNode* cur=newhead;
        //合并
        while(cur1||cur2)
        {
            if(cur1)
            {
                cur->next=cur1;
                cur=cur1;
                cur1=cur1->next;
              
            }
            if(cur2)
            {
                cur->next=cur2;
                cur=cur2;
                cur2=cur2->next;
            }

        }
        
        
    }
};

第二章：合并K个升序链表

2.1 题目链接：https://leetcode.cn/problems/merge-k-sorted-lists/description/

2.2 题目分析：

题目给定K个升序链表，要求将其合并为一个总的升序链表
必须进行节点的依次修改连接，而非单纯修改值

2.3 思路讲解：

此题的核心在于每一个链表自身已经是升序排列。

我们可以采用优先级队列priority_queue，建立一个小根堆，将各个链表的头节点依次入堆。
由于链表为自定义类型，还需要我们定义一个比较函数
此时堆内已经按照节点大小依次排列，之后持续出堆进堆即可完成合并排序。

2.4 代码实现：

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //自定义比较函数
        struct cmp
        {
            bool operator() (const ListNode* l1,const ListNode* l2)
            {
                return l1->val>l2->val;
            }
        };
        //建立小根堆
        priority_queue<ListNode*,vector<ListNode*>,cmp> min;
        for(auto e:lists)
        {
            if(e)
            min.push(e);
        }
        ListNode* newhead=new ListNode(0);
        ListNode* cur=newhead;
        while(!min.empty())
        {
            ListNode* newnode=min.top();
            min.pop();
            if(newnode->next)
            min.push(newnode->next);//进出操作
            cur->next=newnode;
            cur=newnode;//连接

        }
        return newhead->next;
    }
};

第三章：K个一组翻转链表

3.1 题目链接：https://leetcode.cn/problems/reverse-nodes-in-k-group/description/

3.2 题目分析：

现给定链表，要求每k个节点进行一次逆序重排
剩余不足K的节点按照原顺序链接
必须修改节点连接，而非单纯修改节点的值

3.3 思路讲解：

本题的核心操作即为逆序，而逆序我们已经了解了一种极为便捷的方法——头插。

我们可以首先计算出需要翻转的次数，若节点个数为n，则翻转次数为n/k。
此后进行n/k次翻转并依次连接即可。

3.4 代码实现：

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        int n=0;
        ListNode* cur=head;
        while(cur)
        {
            n++;
            cur=cur->next;
        }//计算节点个数
        n/=k;//计算翻转次数
        ListNode* newhead=new ListNode(0);
        ListNode* prev=newhead;
        cur=head;
       for(int j=0;j<n;j++)
       {
            //逆序
            ListNode* temp=cur;
            for(int i=0;i<k;i++)
            {
                ListNode* next=cur->next;
                cur->next=prev->next;
                prev->next=cur;
                cur=next;

            }
            prev=temp;

        }
        //连接剩余部分
        if(cur)
        prev->next=cur;
        prev=newhead->next;
        delete newhead;
        return prev;

        
        
    }
};