Leetcode-Sort List

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

Analsys:

We use Merge Sort.

NOTE: We should practice other sort algorithm, linke Quick Sort and Heap Sort!

Solution:

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        if (head==null || head.next==null) return head;

        head = sortListRecur(head);
        return head;
    }

    public ListNode sortListRecur(ListNode head){
        int len = 1;
        ListNode curNode = head;
        while (curNode.next!=null){
            curNode = curNode.next;
            len++;
        }

        if (len==1) return head;
        ListNode leftHead = head;
        ListNode rightHead = null;
        curNode = head;
        for (int i=1;i<len/2;i++){
            curNode = curNode.next;
        }
        rightHead = curNode.next;
        curNode.next = null;

        leftHead = sortListRecur(leftHead);
        rightHead = sortListRecur(rightHead);

        ListNode preHead = new ListNode(0);
        ListNode end = preHead;
        while (leftHead!=null || rightHead!=null){
            if (leftHead==null){
                end.next = rightHead;
                break;
            }

            if (rightHead==null){
                end.next = leftHead;
                break;
            }

            if (leftHead.val<rightHead.val){
                end.next = leftHead;
                leftHead = leftHead.next;
                end = end.next;
            } else {
                end.next = rightHead;
                rightHead = rightHead.next;
                end = end.next;
            }
        }

        return preHead.next;
    }

}