148排序链表

一、前言

标签：归并排序。

问题来源LeetCode 148 难度：中等。

问题链接：https://leetcode-cn.com/problems/sort-list/

 

二、题目

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例1：

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

三、思路

归并排序可以满足时间复杂度为O(nlogn)。归并排序图如下，也可以参考《十大经典排序》

 

四、编码实现

//==========================================================================
/*
* @file    : 148_SortList.h
* @label   : 归并排序
* @blogs   : https://blog.csdn.net/nie2314550441/article/details/107571597
* @author  : niebingyu
* @date    : 2020/07/24
* @title   : 148.排序链表
* @purpose : 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。
*
* 示例1：
*   输入: 4->2->1->3
*   输出: 1->2->3->4
*
* 示例2:
*   输入: -1->5->3->4->0
*   输出: -1->0->3->4->5
*
* 来源：力扣（LeetCode）
* 难度：中等
* 链接：https://leetcode-cn.com/problems/sort-list/
*/
//==========================================================================
#pragma once
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
using namespace std;

#define NAMESPACE_SORTLIST namespace NAME_SORTLIST {
#define NAMESPACE_SORTLISTEND }
NAMESPACE_SORTLIST
struct ListNode 
{
    int val;
    ListNode* next;
    ListNode(int x, ListNode* _next = nullptr) : val(x), next(_next) {}
};

class Solution 
{
public:
    ListNode* sortList(ListNode* head) 
    {
        if (head == nullptr || head->next == nullptr)
            return head;

        ListNode* pmid = nullptr;
        ListNode* mid = head;
        ListNode* trail = head;
        while (trail && trail->next)
        {
            pmid = mid;
            mid = mid->next;
            trail = trail->next->next;
        }
        pmid->next = nullptr;
        return twoWayMerge(sortList(head), sortList(mid));
    }

    ListNode* twoWayMerge(ListNode* l1, ListNode* l2)
    {
        ListNode header(-1);
        ListNode *p = &header;
        while (l1 && l2)
        {
            if (l1->val < l2->val)
            {
                p->next = l1;
                l1 = l1->next;
            }
            else
            {
                p->next = l2;
                l2 = l2->next;
            }

            p = p->next;
        }

        p->next = l1 == NULL ? l2 : l1;
        return header.next;
    }
};

以下为测试代码//
// 测试 用例 START
void test(const char* testName, ListNode* head, ListNode* expect)
{
    // 测试用例申请的内存没有释放
    Solution s;
    ListNode* result = s.sortList(head);
    bool ret = true;
    while (result && expect)
    {
        if (result->val != expect->val)
        {
            ret = false;
            break;
        }

        result = result->next;
        expect = expect->next;
    }

    if (result != nullptr || expect != nullptr)
        ret = false;
    
    if (ret)
        cout << testName << ", solution passed." << endl;
    else
        cout << testName << ", solution failed. " << endl;
}

// 测试用例
void Test1()
{
    //4->2->1->3
    ListNode* ln_1_3 = new ListNode(3);
    ListNode* ln_1_1 = new ListNode(1, ln_1_3);
    ListNode* ln_1_2 = new ListNode(2, ln_1_1);
    ListNode* ln_1_4 = new ListNode(4, ln_1_2);

    //1->2->3->4
    ListNode* ln_2_4 = new ListNode(4);
    ListNode* ln_2_3 = new ListNode(3, ln_2_4);
    ListNode* ln_2_2 = new ListNode(2, ln_2_3);
    ListNode* ln_2_1 = new ListNode(1, ln_2_2);

    ListNode* head = ln_1_4;
    ListNode* expect = ln_2_1;
    test("Test1()", head, expect);
}

NAMESPACE_SORTLISTEND
// 测试 用例 END
//
void SortList_Test()
{
    cout << "------ start 148.排序链表 ------" << endl;
    NAME_SORTLIST::Test1();
    cout << "------ end 148.排序链表 --------" << endl;
}

执行结果：