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