LeetCode_Sort List

最新推荐文章于 2024-08-19 16:35:52 发布

原创最新推荐文章于 2024-08-19 16:35:52 发布 · 1.4k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

LeetCode 专栏收录该内容

47 篇文章

订阅专栏

本文介绍了一种在O(nlogn)时间内使用常数空间复杂度对链表进行排序的方法，通过采用归并排序实现，避免了额外的空间开销。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

题目很简单，就是对一个单链表进行排序，但是要求时间复杂度为O(nlogn)空间复杂度在常数范围内。

分析：

1)提到排序：按照算法导论上描述：

插入排序，平均时间复杂度O(n2)，原地排序

归并排序（O(nlogn)），非原地排序（额外申请空间）

堆排序（O(nlogn)），原地排序

快排（期望:O(nlogn)，最坏O(n2)），原地排序

2）由此定位在归并排序和堆排序上，我最初的想法是堆排序，但这里给的是链表，而算法导论中给出的是以数组的形式，行不通了；

3）在Discuss上看了别人的方法（自己没想到），原来就是归并排序，只需改变链表指向就可以了，无需申请额外空间，代码如下：

 // Definition for singly-linked list.
 struct ListNode {
      int val;
      ListNode *next;
      ListNode(int x) : val(x), next(NULL) {}
  };
 
class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if (head==NULL)
        {
            return NULL;
        }
        
        //计算List长度
        int listLen=0;
        ListNode *p=head;
        while (p!=NULL)
        {
            listLen++;
            p=p->next;
        }
        head=MergeSort(head,listLen);
        return head;
    }

    ListNode* merge(ListNode *p1,ListNode *p2)
    {
        ListNode *phead;
        ListNode *head;
        if (p1->val>=p2->val)
        {
            phead=p2;
            p2=p2->next;
        }
        else
        {
            phead=p1;
            p1=p1->next;
        }
        head=phead;
        phead->next=NULL;

        while (p1!=NULL&&p2!=NULL)
        {
            if (p1->val>=p2->val)
            {
                phead->next=p2;
                p2=p2->next;
            }
            else
            {
                phead->next=p1;
                p1=p1->next;
            }
            phead=phead->next;
            phead->next=NULL;
        }

        if (p1==NULL)
        {
            phead->next=p2;
        }
        else
        {
            phead->next=p1;
        }
        return head;
    }
    ListNode* MergeSort(ListNode *head,int listLen)
    {
        if (listLen==1||listLen==0)
        {
            return head;
        }
        
        int mid=listLen/2;
        ListNode *p1;
        ListNode *p2;

        p2=p1=head;
        //分段，查找第二段的起点并设置第一段的终点
        int i=1;
        while (i<mid)
        {
              i++;
              if (p2!=NULL)
              {
                  p2=p2->next;
              }
              else
              {
                  break;
              }
        }
        if (p2!=NULL)
        {
            ListNode *p1buttom=p2;
            p2=p2->next;
            p1buttom->next=NULL;
        }
        
        p1=MergeSort(p1,mid);
        p2=MergeSort(p2,listLen-mid);

        head=merge(p1,p2);
        return head;
    }
};