sort-list

原创 2018年04月16日 18:04:46

Sort a linked list in O(n log n) time using constant space complexity.

实现一个对链表排序的算法,要求时间复杂度为O(nlogn),空间复杂度为O(1)

思路一:

首先想到的是快排,快排代码在下面,可是提交之后总是运行超时,这里做一下分析:
首先分析空间复杂度,一般来说,快排的空间复杂度是O(logn),因为快排是递归调用,每次调用都要用常数的空间,由于对链表进行排序,所以实际上排完序后指向链表节点的指针可以复用,从而实现O(1)的空间复杂度。
其次分析时间复杂度,快排的平均时间复杂度为O(nlogn), 可是最坏的情况为O(n^2),也就是说快排的时间是不稳定的,如果给的测试用例刚好是逆序的,就会到最坏情况。所以会超时,那么需要一种时间比较稳定的算法,选择归并。快排代码如下

#include <iostream>
#include "../coding interviews/Utilities/List.h"
using namespace std;
         ListNode* pNext = nullptr;//内循环指针
         ListNode* pPNext = nullptr;//永远跟在pNext的前一个
        // ListNode* pHead  = nullptr;//标示头指针
         ListNode* temp = nullptr;
         bool ishead    = true;
    ListNode* sortListCore(ListNode *pbegin, ListNode* pend, ListNode* pPreBegin, ListNode* pHead)
    {
        if(pbegin == pend)
            return pbegin;

         ishead = true;//用来确定头指针的位置,头指针是第一个移到pNode前的节点
         pNext = pbegin->m_pNext;//内循环指针
         pPNext = pbegin;//永远跟在pNext的前一个
         pHead  = pbegin;//标示头指针
         temp = nullptr;
         while(pNext != pend)
            {
                if(pbegin->m_nValue > pNext->m_nValue)
                {
                    if(pPreBegin == nullptr)
                    {
                        temp = pNext->m_pNext;
                        pNext->m_pNext = pbegin;
                        pPNext->m_pNext = temp;
                        pPreBegin    = pNext;
                        pNext       = pPNext->m_pNext;
                        if(ishead)
                        {
                            pHead = pPreBegin;
                            ishead = false;
                        }
                    }
                    else
                    {
                        temp = pNext->m_pNext;
                        pNext->m_pNext    = pbegin;
                        pPNext->m_pNext    = temp;
                        pPreBegin->m_pNext = pNext;
                        pPreBegin       = pNext;
                        pNext          = pPNext->m_pNext;
                    }
                }
                else
                {
                    pPNext = pNext;
                    pNext = pNext->m_pNext;
                }
            }

        sortListCore(pbegin->m_pNext, nullptr, pbegin, pHead);
        pHead = sortListCore(pHead, pbegin, nullptr, pHead);
        return pHead;
    }

    ListNode *sortList(ListNode *head)
    {
//        if(head == nullptr)
//            return nullptr;
//        ListNode* pNode = head;//外循环指针
        //ListNode* pPreNode = nullptr;//永远跟在pNode的前一个

       return sortListCore(head, nullptr, nullptr, head);

    }

int main()
{
    ListNode* pNode1 = CreateListNode(5);
    ListNode* pNode2 = CreateListNode(4);
    ListNode* pNode3 = CreateListNode(6);
    ListNode* pNode4 = CreateListNode(2);
    ListNode* pNode5 = CreateListNode(1);
    ListNode* pNode6 = CreateListNode(0);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);
    ConnectListNodes(pNode5, pNode6);

    PrintList(pNode1);

    ListNode* newNode = sortList(pNode1);

    PrintList(newNode);
}

思路二

既然快排行不通,那就用归并吧,直接上代码


//  struct ListNode {
//      int val;
//      ListNode *next;
//      ListNode(int x) : val(x), next(nullptr) {}
//  };
#include <iostream>
#include "../coding interviews/Utilities/List.h"
using namespace std;
         ListNode* pRNext = nullptr;//要归并的后一个数组的头指针
         ListNode* pLNext  = nullptr;//要归并的前一个数组的头指针

         ListNode* temp = nullptr;
         ListNode* pmid = nullptr;//标示中间节点的位置
    ListNode* Getmid(ListNode *pbegin, ListNode* pend)
    {
        temp = pbegin;
        pmid  = pbegin;
        if(temp == pend)
        {
            return temp;
        }
        else
        {
            temp = temp->next;
            if(temp == pend)
                return pmid;
            else
                temp = temp->next;
        }

        while(temp != pend && temp->next != pend)
        {
            pmid = pmid->next;
            temp = temp->next->next;
        }
        return pmid;
    }

    ListNode* sortListCore(ListNode *pbegin, ListNode* pend, ListNode* pmiddle)
    {
        if(pbegin != pmiddle->next && pmiddle->next->next != pend && pmiddle->next != pend)
        {
            pmid = Getmid(pmiddle->next,  pend);
            pmiddle->next = sortListCore(pmiddle->next, pend, pmid);
            //PrintList(pmiddle->next);
            pmid = Getmid(pbegin,  pmiddle->next);
            pbegin = sortListCore(pbegin, pmiddle->next, pmid);
        }

        pLNext = pbegin;
        pRNext = pmiddle->next;
        pmiddle->next = nullptr;//将链表拆开
        ListNode *dumy = CreateListNode(0);
        temp = dumy;

        while(pLNext && pRNext)
        {
            if(pLNext->val > pRNext->val)
            {
                temp->next = pRNext;
                pRNext     = pRNext->next;
                temp = temp->next;
            }
            else
            {
                temp->next = pLNext;
                pLNext     = pLNext->next;
                temp = temp->next;
            }
        }
        if(pLNext)   temp->next = pLNext;
        if(pRNext)   temp->next = pRNext;
        temp = dumy->next;
        delete dumy;
        dumy = nullptr;
        return temp;
    }

    ListNode *sortList(ListNode *head)
    {
        if(head == nullptr)
            return nullptr;
        if(head->next == nullptr)
            return head;
        pmid = Getmid(head, nullptr);
       // PrintListNode(pmid);
        return sortListCore(head, nullptr, pmid);
    }

int main()
{
    ListNode* pNode1 = CreateListNode(3);
    ListNode* pNode2 = CreateListNode(4);
    ListNode* pNode3 = CreateListNode(1);
//    ListNode* pNode4 = CreateListNode(0);
//    ListNode* pNode5 = CreateListNode(1);
//    ListNode* pNode6 = CreateListNode(4);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
//    ConnectListNodes(pNode3, pNode4);
//    ConnectListNodes(pNode4, pNode5);
//    ConnectListNodes(pNode5, pNode6);

    PrintList(pNode1);

    ListNode* newNode = sortList(pNode1);

    PrintList(newNode);

    DestroyList(newNode);
}

这个代码需要注意俩点,第一点是结束条件要小心,需要考虑各种不同的情况,因为我返回的是后一个需要归并的链表的前一个节点的指针,所以要特别小心,后一个链表不存在,或存在只有一个节点的情况,同样在获得中间节点函数中也要考虑到这几种情况;第二个需要注意的点是,归并可以直接用一个指针来表示新建立的链表,因此避免了O(n)的辅助空间,但是在做归并是必须先把原链表断开,断开之后不能丢节点才可以。我原先的想法是移动节点的位置,只要对要移动和要插入的节点做好记录(保留前一个节点),就可以实现O(1)时间复杂度的节点移动,但是实际运行发现超内存,我的思路还是不够“归并”,所以改成如上所示的代码。

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/wzc2608/article/details/79957142

【sort-list】

Sort a linked list in O(n log n) time using constant space complexity. 题意实现一个链表排序的算法; 方法一:刚开...
  • lplp90908
  • lplp90908
  • 2017-09-01 21:22:15
  • 50

leetcode sort-list

https://oj.leetcode.com/problems/sort-list/点击打开链接 题目描述: Sort a linked list in O(n log n) time using ...
  • ych_ding
  • ych_ding
  • 2014-11-25 22:10:23
  • 279

【leetcode】:sort-list

Sort a linked list in O(n log n) time using constant space complexity. 用常数空间复杂度对O(n log n)时的链表排序。...
  • WX_East
  • WX_East
  • 2017-04-28 16:02:36
  • 106

Sort List -- LeetCode

原题链接: http://oj.leetcode.com/problems/sort-list/  这道题题目要求我们用O(nlogn)算法对链表进行排序,但是并没有要求用哪一种排序算法,我们可以使用...
  • linhuanmars
  • linhuanmars
  • 2014-03-14 08:16:52
  • 16175

leetcode:sort-list

1.题目描述 Sort a linked list in O(n log n) time using constant space complexity。 2.实现 (1)堆排序实现,它的时...
  • tangli555
  • tangli555
  • 2016-06-07 15:33:10
  • 162

sort-list(Leetcode)

链表的排序
  • sxd8700
  • sxd8700
  • 2016-05-30 18:10:53
  • 173

Leetcode: sort-list

题目: Sort a linked list in O(n log n) time using constant space complexity. 分析: 在排序算法中,时间复杂度为O(n ...
  • weixin_37933986
  • weixin_37933986
  • 2017-05-23 12:21:29
  • 104

[LeetCode] sort-list

sort-list 题目描述Sort a linked list in O(n log n) time using constant space complexity. 链表排序。。要求用O(n...
  • u014293306
  • u014293306
  • 2016-08-12 21:48:47
  • 159

leetcode之sort-list

题目描述 Sort a linked list in O(n log n) time using constant space complexity.因为题目要求复杂度为O(nlogn),故可以考虑...
  • ivolcano
  • ivolcano
  • 2017-03-04 14:14:15
  • 95

Leetcode在线编程sort-list

Leetcode在线编程sort-list 单链表快速排序
  • zero_witty
  • zero_witty
  • 2016-11-28 19:22:16
  • 159
收藏助手
不良信息举报
您举报文章:sort-list
举报原因:
原因补充:

(最多只允许输入30个字)