Sort List

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

题目分析：给一个链表排序，这玩意有点不好弄

思路解析：  本题先将链表拆成俩个 （拆后要将俩个链表恢复成正常），递归的将俩个字链表排序， 最后将结果合并，思路简单但是操作起来不好弄，直接上AC代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
 /**
  * 本题先将链表拆成俩个
  * 递归的将俩个字链表排序
  * 最后将结果合并
  * */
public class Solution {
    // merge sort
	public static ListNode sortList(ListNode head) {
                //安全性检查
		if (head == null || head.next == null)
			return head;
 
		// 计算链表长度
		int count = 0;
		ListNode p = head;
		while (p != null) {
			count++;
			p = p.next;
		}
 
		// 将链表打破为2个链表
		int middle = count / 2;
                //将截断链表恢复成俩个正常链表
		ListNode l = head, r = null;
		ListNode p2 = head;
		int countHalf = 0;
		while (p2 != null) {
			countHalf++;
			ListNode next = p2.next;
 
			if (countHalf == middle) {
				p2.next = null;
				r = next;
			}
			p2 = next;
		}
 
		//递归俩个链表
		ListNode h1 = sortList(l);
		ListNode h2 = sortList(r);
 
		// 合并
		ListNode merged = merge(h1, h2);
 
		return merged;
	}
 
	public static ListNode merge(ListNode l, ListNode r) {
		ListNode p1 = l;
		ListNode p2 = r;
 
		ListNode fakeHead = new ListNode(100);
		ListNode pNew = fakeHead;
 
		while (p1 != null || p2 != null) {
 
			if (p1 == null) {
				pNew.next = new ListNode(p2.val);
				p2 = p2.next;
				pNew = pNew.next;
			} else if (p2 == null) {
				pNew.next = new ListNode(p1.val);
				p1 = p1.next;
				pNew = pNew.next;
			} else {
				if (p1.val < p2.val) {
					// if(fakeHead)
					pNew.next = new ListNode(p1.val);
					p1 = p1.next;
					pNew = pNew.next;
				} else if (p1.val == p2.val) {
					pNew.next = new ListNode(p1.val);
					pNew.next.next = new ListNode(p1.val);
					pNew = pNew.next.next;
					p1 = p1.next;
					p2 = p2.next;
 
				} else {
					pNew.next = new ListNode(p2.val);
					p2 = p2.next;
					pNew = pNew.next;
				}
			}
		}
 
		return fakeHead.next;
	}
}