148 Sort List

最新推荐文章于 2024-03-28 12:36:07 发布

原创最新推荐文章于 2024-03-28 12:36:07 发布 · 514 阅读

0 ·

CC 4.0 BY-SA版权

编程开发同时被 2 个专栏收录

27 篇文章

订阅专栏

LeetCode

24 篇文章

订阅专栏

本文介绍了一种基于链表的排序算法实现，该算法采用分治策略，利用快慢指针技术将链表一分为二，递归地进行排序，最终通过合并操作得到有序链表。时间复杂度为O(nlog(n))，空间复杂度为常数级别。

模板题。这个题的要求是让我们找出一种时间复杂度是O(nlog(n))，空间复杂度是常数级的。这个就可以这么办，使用slow-fast技术将链表分成两部分，所谓slow-fast技术是指，快指针走两个，慢指针走一个，当快指针到头了，慢指针恰好指向中心。这样我们就不需要额外的空间了。代码如下：

class Solution {
public:
      ListNode *sortList(ListNode *head) {  
        if(!head||!head->next)  
            return head;  
        return mergeSort(head);  
    }  
    ListNode * mergeSort(ListNode *head){  
        if(!head||!head->next)   //just one element  
            return head;  
        ListNode *p=head, *q=head, *pre=NULL;  
        while(q&&q->next!=NULL){  
            q=q->next->next;  
            pre=p;  
            p=p->next;  //divide into two parts  
        }  
        pre->next=NULL;  
        ListNode *lhalf=mergeSort(head);  
        ListNode *rhalf=mergeSort(p);  //recursive  
        return merge(lhalf, rhalf);   //merge  
    }  
    ListNode * merge(ListNode *lh, ListNode *rh){  
        ListNode *temp=new ListNode(0);  
        ListNode *p=temp;  
        while(lh&&rh){  
            if(lh->val<=rh->val){  
                p->next=lh;  
                lh=lh->next;  
            }  
            else{  
                p->next=rh;  
                rh=rh->next;  
            }  
            p=p->next;  
        }  
        if(!lh)  
            p->next=rh;  
        else  
            p->next=lh;  
        p=temp->next;  
        temp->next=NULL;  
        delete temp;  
        return p;  
    }  
};