leetcode: sortlist之四种方法

原题链接：https://oj.leetcode.com/problems/sort-list/

题目：空间复杂度为常数，时间复杂度为O(nlogn)的排序链表实现

方法一：第一想法是模拟数组的快速排序，参考了算法导论，于是思路被牵到了如何处理交换节点上，几经波折总算实现，不过提交的结果TLE。

 /**
  * Definition for partition method result value
  *
  */
 class PartitionResult {
     ListNode head;
     ListNode tail;
     ListNode pre_pivot;
     ListNode pivot_node;

     public PartitionResult(ListNode head, ListNode tail) {
         // TODO Auto-generated constructor stub
         this.head = head;
         this.tail = tail;
         pre_pivot = null;
         pivot_node = null;
     }
 }

 public class Solution {
     ListNode head = null;

     private void swap(ListNode prei, ListNode i, ListNode prej, ListNode j) {
         if (i != prej) { //i isn't adjacent to j
             if (prei != null) //prei == null means i is the list's head
                 prei.next = j;

             ListNode cpy = j.next;
             j.next = i.next;

             prej.next = i;
             i.next = cpy;
         }
         else { //i adjacent to j means i == prej
             if (prei != null) //prei == null means i is the list's head
                 prei.next = j;

             ListNode cpy = j.next;
             j.next = i;
             i.next = cpy;
         }
     }

     /**
      * partition [p, r] inplace and return [head, tail, pre_pivot, pivot_node]
      *
      * @param preP
      * @param p
      * @param r
      * @param nextR
      * @return
      */
     private PartitionResult partition(ListNode prep, ListNode p, ListNode r) {
         int pivot_element = r.val;

         PartitionResult partitionResult = new PartitionResult(p, r);

         ListNode i = prep;
         ListNode prei = null;
         ListNode prej = prep;

         for (ListNode j = p; j != r; prej = j, j = j.next) {
             if (j.val <= pivot_element) {

                 prei = i;

                 //++i
                 if (i != null) {
                     i = i.next;
                 }
                 else {
                     i = partitionResult.head;
                     partitionResult.head = j; //modify cur head

                     if (this.head == i)
                         this.head = j;
                 }

                 //swap i node and j node
                 if (i != j) {
                     swap(prei, i, prej, j);

                     //swap i and j reference
                     ListNode cpy = i;
                     i = j;
                     j = cpy;
                 }
             }
         }

         //swap i + 1 node and r node
         if (i != null) {
             prei = i;
             i = i.next;
         }
         else {
             i = partitionResult.head;
             partitionResult.head = r;

             if (this.head == i)
                 this.head = r;
         }

         swap(prei, i, prej, r);

         ListNode cpy = i;
         i = r;
         r = cpy;

         //modify tail
         partitionResult.tail = i;

         //set new pre pivot node and pivot node
         partitionResult.pre_pivot = prej;
         partitionResult.pivot_node = i; 

         return partitionResult;
     }

     /**
      * single linked list quickSort [head, tail]
      * @param head
      * @param tail
      * @return
      */
     private void quickSort(ListNode preHead, ListNode head, ListNode tail) {
         if (head != null && tail != null && head != tail) {
             PartitionResult partitionResult = partition(preHead, head, tail);

             quickSort(preHead, partitionResult.head, partitionResult.pre_pivot);

             if (partitionResult.pivot_node != partitionResult.tail)
                 quickSort(partitionResult.pivot_node, partitionResult.pivot_node.next, partitionResult.tail);
         }
     }

     public ListNode sortList(ListNode head) {
         this.head = head;
         ListNode tail = null;

         for (ListNode itr = head; itr != null; tail = itr, itr = itr.next);

         quickSort(null, head, tail);

         return head;
     }
 }

方法一的缺点很明显：复杂容易出错，没有利用链表的优势。数组快排交换节点的本质，是使得在左边元素<=Pivot元素<=右边元素，因此在对链表进行快排时，可以构造左链表(l1)，右链表(l2)，及Pivot元素(x)，使得l1 <= x < l2，再将l1 -> x -> l2相连，由此得到方法二。方法二的代码量较之方法一减少一半，无奈提交的结果仍然是TLE，错误的case与方法一一致，都是一个超长的输入。

public class Solution {
    /**
     * core idea is the link not swap
     * head != null
     * and use the head node as a pivot node
     *
     * [head, tail)
     *
     * @param head
     * @param tail
     * @return current head node
     */
    private ListNode partition(ListNode head, ListNode tail) {
        int x = head.val;

        //l1 <= x
        //l2 > x
        ListNode l1Head = new ListNode(-1), l1Itr = l1Head;
        ListNode l2Head = new ListNode(-1), l2Itr = l2Head;

        for (ListNode itr = head.next; itr != tail; itr = itr.next) {
            if (itr.val <= x) {
                l1Itr.next = itr;
                l1Itr = itr;
            }
            else {
                l2Itr.next = itr;
                l2Itr = itr;
            }
        }

        //l1->x->l2->tail
        l1Itr.next = head;
        l2Itr.next = tail; //if l2Head == l2Itr
        head.next = l2Head.next;

        //useless node set to null
        ListNode relHead = l1Head.next;
        l1Head = null;
        l2Head = null;

        return relHead;
    }

    //quick sort for list
    private ListNode quickSort(ListNode head, ListNode tail) {
        ListNode curHead = head;

        if (head != tail) {
            curHead = partition(head, tail); //after partition head node play a pivot role

            curHead = quickSort(curHead, head); //maintain head node

            head.next = quickSort(head.next, tail); //link two parts
        }

        return curHead;
    }

    public ListNode sortList(ListNode head) {
        return quickSort(head, null);
    }
}

影响快排性能的一个重要因素，就是Pivot元素的选取。方法二简单的使用了链表中的第一个节点作为Pivot元素，并不能保证很好的平均性能。参考了Discuss中一位网友取链表均值作为Pivot值的思路，实现了方法三。注意，之所以说是Pivot值，是因为与方法一，方法二在链表中选取Pivot元素不同，该Pivot值可能不在链表中。

 public class Solution {
     /**
      * core idea is the link not swap
      * head != null
      * and use the head node as a pivot node
      *
      * [head, tail)
      *
      * @param head
      * @param tail
      * @return [leftPartHead, leftPartEndNode]
      */
     private ListNode[] partition(ListNode head, ListNode tail) {
         //cal avg as the pivot value
         int sum = 0, count = 0;

         for (ListNode itr = head; itr != tail; itr = itr.next) {
             sum += itr.val;
             ++count;
         }

         float x = (float)sum / count; //notice if int x will lead to infinite loop (for example -39 -38)

         boolean same = true;

         //l1 <= x
         //l2 > x
         ListNode l1Head = new ListNode(-1), l1Itr = l1Head;
         ListNode l2Head = new ListNode(-1), l2Itr = l2Head;

         for (ListNode itr = head, pre = head; itr != tail; pre = itr, itr = itr.next) {
             if (itr.val != pre.val) {
                 same = false;
             }

             if (itr.val < x) {
                 l1Itr.next = itr;
                 l1Itr = itr;
             }
             else {
                 l2Itr.next = itr;
                 l2Itr = itr;
             }
         }

         ListNode [] listNodes = new ListNode[2];

         listNodes[0] = l1Head.next;

         if (!same) {
             //l1->l2->tail
             l2Itr.next = tail; //if l2Head == l2Itr
             l1Itr.next = l2Head.next;

             listNodes[1] = l1Itr;
         }
         else {
             listNodes[1] = l1Head.next;
         }

         //useless node set to null
         l1Head = null;
         l2Head = null;

         return listNodes;
     }

     //quick sort for list
     private ListNode quickSort(ListNode head, ListNode tail) {
         ListNode curHead = head;

         if (head != tail && head.next != tail) {
             ListNode [] rel = partition(head, tail); //after partition head node play a pivot role

             if (rel[0] != null) { //when rel[0] means that remain element is the same
                 curHead = quickSort(rel[0], rel[1].next); //maintain head node

                 rel[1].next = quickSort(rel[1].next, tail); //link the two parts
             }
         }

         return curHead;
     }

     public ListNode sortList(ListNode head) {
         return quickSort(head, null);
     }
 }

方法三的trap：

1. 由于采用均值作为Pivot值，因此当链表中元素相等时，是没法继续划分的（当然也不需要继续划分，即可以结束），会造成无限循环

2. 题目中给的链表元素值为int型，如果均值为int，也会造成无法继续划分的情况，如{5, 6}，均值为5，那么5, 6将被归为右链表，并且那么持续下去，造成无限循环

方法三提交结果总算AC啦(512ms)，时间有波动。

方法四不再死磕链表快排，采用归并排序，对于此题来说，应该是比较直接合理的解决方案。值得注意的是怎么确定链表的中点（经典问题啦）：中点意味着2*mid = length，因此可以设置两个引用，mid引用一次走一个节点，itr引用一次走两个节点，当itr到链表尾的时候，mid就在近似链表中间的位置了。之所以说是近似呢，是因为在我的代码中，mid和itr都是从链表中的第一个节点开始遍历的，因此length相当于-1了，对于奇数节点来说，mid为实际中间节点+1，偶数节点为中间节点右边那个节点。

 public class Solution {
     /**
      * merge l1 and l2 list
      *
      * @param l1
      * @param l2
      * @return
      */
     private ListNode merge(ListNode l1, ListNode l2) {
         ListNode head = new ListNode(-1), itr = head;

         while (l1 != null && l2 != null) {
             if (l1.val < l2.val) {
                 itr.next = l1;
                 itr = l1;
                 l1 = l1.next;
             }
             else {
                 itr.next = l2;
                 itr = l2;
                 l2 = l2.next;
             }
         }

         //deal l1 or l2 remain element
         ListNode remail = null;

         if (l1 == null && l2 != null) {
             remail = l2;
         }
         else if (l2 == null && l1 != null) {
             remail = l1;
         }

         itr.next = remail;

         ListNode relHead = head.next;
         head = null;

         return relHead;
     }

     private ListNode mergeSort(ListNode head, ListNode tail) {
         if (head.next == tail) { //single node
             head.next = null;
             return head;
         }

         //locate the middle node
         //2 * mid = len
         //itr += 2; mid += 1;
         //notice that itr and mid start from the first node so it is not a exact middle location
         //actually it is the middle location + 1
         ListNode itr = head, mid = head;
         while (itr != tail) {
             itr = itr.next;

             if (itr != tail) {
                 itr = itr.next;
             }

             mid = mid.next;
         }

         ListNode l1 = mergeSort(head, mid);

         ListNode l2 = mergeSort(mid, tail);

         return merge(l1, l2);
     }

     public ListNode sortList(ListNode head) {
         if (head == null) //trap
             return null;

         return mergeSort(head, null);
     }
 }

方法四提交结果AC(500ms)，时间有波动。

github地址：https://github.com/zrss/leetcode/tree/master/src/com/zrss/leetcode