148. Sort List

最新推荐文章于 2021-07-28 17:24:44 发布

mingyangdai

最新推荐文章于 2021-07-28 17:24:44 发布

阅读量171

点赞数

分类专栏：数据结构&算法文章标签：算法

本文链接：https://blog.csdn.net/daimingyang123/article/details/78609117

版权

数据结构&算法专栏收录该内容

94 篇文章 0 订阅

订阅专栏

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

觉得这个可以归到hard里面了

O(nlogn)的排序首先想到的是qucik sort，merge sort之类但是因为递归调用会有入栈操作空间复杂度O(logn)

discuss里面的最高vote 就是常规的merge sort 是错误的…

第二名是正确的 code如下

/**
 * Merge sort use bottom-up policy, 
 * so Space Complexity is O(1)
 * Time Complexity is O(NlgN)
 * stable sort
*/
class Solution {
public:
        ListNode *sortList(ListNode *head) {
                if(!head || !(head->next)) return head;
                
                //get the linked list's length
                ListNode* cur = head;
                int length = 0;
                while(cur){
                        length++;
                        cur = cur->next;
                }
                
                ListNode dummy(0);
                dummy.next = head;
                ListNode *left, *right, *tail;
                for(int step = 1; step < length; step <<= 1){
                        cur = dummy.next;
                        tail = &dummy;
                        while(cur){
                                left = cur;
                                right = split(left, step);
                                cur = split(right,step);
                                tail = merge(left, right, tail);
                        }
                }
                return dummy.next;
        }
private:
        /**
         * Divide the linked list into two lists,
     * while the first list contains first n ndoes
         * return the second list's head
         */
        ListNode* split(ListNode *head, int n){
                //if(!head) return NULL;
                for(int i = 1; head && i < n; i++) head = head->next;
                
                if(!head) return NULL;
                ListNode *second = head->next;
                head->next = NULL;
                return second;
        }
        /**
          * merge the two sorted linked list l1 and l2,
          * then append the merged sorted linked list to the node head
          * return the tail of the merged sorted linked list
         */
        ListNode* merge(ListNode* l1, ListNode* l2, ListNode* head){
                ListNode *cur = head;
                while(l1 && l2){
                        if(l1->val > l2->val){
                                cur->next = l2;
                                cur = l2;
                                l2 = l2->next;
                        }
                        else{
                                cur->next = l1;
                                cur = l1;
                                l1 = l1->next;
                        }
                }
                cur->next = (l1 ? l1 : l2);
                while(cur->next) cur = cur->next;
                return cur;
        }
};

思路:

this problem can be easily solved using recurrence and divide-and-conquer. But it consumes program stack to store the recurring function stack frame, actually it consumes o(lgn) space complexity. Recursion use up-to-bottom strategy , why not try the opposite way--bottom-to-up, luckily it works, it only consumes 0(1) space complexity and o(nlgn) time complextity.

说的挺明确的常规的merge sort 是把集合等分成2个 4个 8个… 直到集合中只有一个元素然后开始merge