C++ 归并排序 《剑指offer2》 链表排序

这道题的要求是在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序，也就是说只有快排 归并排序满足要求 ，且 要在链表本身上做修改，而不能创建新的节点（额外空间）。

这道题十分的经典，完成这道题后可以说做单链表的算法题都不再会有难度，单链表小毕业，而且理解了归并排序。

这道题囊括了递归 分治 双指针中的快慢指针 三种算法思想。

归并排序

归并是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略将问题分成一些小的问题然后递归求解，即分而治之。

其实归并排序很好理解，直接上图

但图看得懂 题不一定会做，接下来来逐步分析

拆分

首先是拆分 从图上可以看到 我们是从中间拆分，但如何快速的找到链表的中间节点是一个问题

这时候就借助了双指针中的快慢指针

    ListNode* spiltList(ListNode* head)
    {
        ListNode* slow=head;
        ListNode* fast=head;
        while(fast->next!=nullptr && fast->next->next!=nullptr)
        {
            slow=slow->next;
            fast=fast->next->next;
        }
        ListNode* backhead=slow->next;
        slow->next=nullptr;
        return backhead;
    }


    在双数节点的链表中 
    例如  1 2 3 4 5 6
    
    while(fast->next!=nullptr && fast->next->next!=nullptr)
    slow 定位到 3

    while(fast!=nullptr && fast->next!=nullptr)
    slow 定位到 4

    两种写法都行，依据题目来写

 这里就简单介绍一下快慢指针，慢指针一次移动一步，快指针一次移动两步，当快指针到达尾部，慢指针刚好到达中间节点。

如果想加深印象 可以做 力扣上 2095.删除链表的中间节点 141. 环形链表 快速上手快慢指针

合并

合并这里已经是需要用到递归的思想，递归还是比较抽象的

如果 这个图看不懂 可以上力扣做一下 21.合并两个有序链表 上面有动图

    ListNode* mergeList(ListNode* l1,ListNode* l2)
    {
        if(l1==nullptr)
        {
            return l2;
        }
        if(l2==nullptr)
        {
            return l1;
        }
        if(l1->val<=l2->val)
        {
            l1->next=mergeList(l1->next,l2);
            return l1;
        }
        else
        {
            l2->next=mergeList(l1,l2->next);
            return l2;
        }
    }

最后是整道题

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) 
    {
        if(head==nullptr || head->next==nullptr)
        {
            return head;
        }
        ListNode* head1=head;
        ListNode* head2=spiltList(head);
        head1=sortList(head1);
        head2=sortList(head2);
        return mergeList(head1,head2);
    }

    ListNode* spiltList(ListNode* head)
    {
        ListNode* slow=head;
        ListNode* fast=head;
        while(fast->next!=nullptr && fast->next->next!=nullptr)
        {
            slow=slow->next;
            fast=fast->next->next;
        }
        ListNode* backhead=slow->next;
        slow->next=nullptr;
        return backhead;
    }

    ListNode* mergeList(ListNode* l1,ListNode* l2)
    {
        if(l1==nullptr)
        {
            return l2;
        }
        if(l2==nullptr)
        {
            return l1;
        }
        if(l1->val<=l2->val)
        {
            l1->next=mergeList(l1->next,l2);
            return l1;
        }
        else
        {
            l2->next=mergeList(l1,l2->next);
            return l2;
        }
    }
};

主函数中也是用了递归的一个思想，其实递归这个东西，靠感觉，题做多了自然就会了。

总结

这道题就是个缝合怪，用快慢指针找到中间节点，分开，在有序的合并。分而治之的理念体现的淋漓尽致。

单链表刷题（力扣）

合并有序链表

环形链表

删除链表的倒数第k个节点

删除链表的中间节点

排序链表