[LeetCode] 148. Sort List 解题思路

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

问题：对一个单列表排序，要求时间复杂度为 O(n*logn)，额外空间为 O(1)。

O(n*logn) 时间排序算法，无法是 quick sort, merge sort, head sort。quick sort 需要灵活访问前后元素，适合于数组，merge sort 只需要从左到右扫过去即可，可用于列表结构。

• 当列表元素个数大于2时，将列表拆分为左右对半的两个子列表，对左右子列表分别排序，然后合并。
• 当列表元素个数小于等于2 时，直接对列表元素比较排序。

第一步中的合并操作，实际上另一个LeetCode题目 Merge Two Sorted Lists

需要注意的是，由于是单向列表，为了方便操作元素位置，每次比较操作比较的是指针的下一个元素，详情见 sortmerge 函数。

     /**
      * p 表示父节点
      * ll, lr 分别表示左半列表的父节点，右半列表的父节点
      *
      */
     ListNode* sortmerge(ListNode* p, int len){

         if (len <= ) {
             return p;
         }

         if (len == ) {
             if (p->next->val > p->next->next->val) {
                 int tmp = p->next->val;
                 p->next->val = p->next->next->val;
                 p->next->next->val = tmp;
             }
             return p;
         }

         int lenL = len / ;
         int lenR = len - lenL;

         ListNode* ll = p;

         ll = sortmerge(ll, lenL);

         ListNode* lr = p;

         for (int i =  ; i < lenL; i++) {
             lr = lr->next;
         }

         lr = sortmerge(lr, lenR);

         while (ll != lr && lenR > ) {
             if (ll->next->val <= lr->next->val) {
                 ll = ll->next;
             }else{
                 ListNode* next2 = lr->next;
                 lr->next = lr->next->next;
                 next2->next = ll->next;
                 ll->next = next2;
                 lenR--;
             }
         }

         return p;
     }

     ListNode* sortList(ListNode* head) {

         ListNode* node = head;

         int cnt = ;
         while (node != NULL) {
             cnt++;
             node = node->next;
         }

         ListNode* p = new ListNode();
         p->next = head;

         p = sortmerge(p, cnt);

         head = p->next;

         return head;
     }

参考资料：

[LeetCode] Sort List, Solution, 水中的鱼