微软面试题 : 链表排序

很经典的一道题，既然是面试拿出来，肯定是要求 O(n * logn) 的时间复杂度了。
另有经典：链表 K 个节点为一组进行逆序:

https://blog.youkuaiyun.com/qq_37186947/article/details/104119152

递归，可以用快排或者归排 , 这里使用归排，先用快慢指针法找到中间节点，然后断开连接，分治处理两个部分，最后合并。不像数组归排，这里只用到了一个 dummy 指针 (临时头节点，关于链表的题目经常使用)，所以空间复杂度只有递归栈 O(logn). 要注意的是 merge（node1， node2） 调用时传入的是递归返回的两个节点，而不是 first 和 slow.next 两个最初的头结点。

public class LinkNodeSortTest {

    private static class Node{
        Node next;
        int key;

        public Node(int key, Node next) {
            this.next = next;
            this.key = key;
        }
    }

    private static Node sortList(Node first){
        if(first == null || first.next ==  null) return first;
        // 通过快慢指针，找到中间节点
        Node fast = first, slow = first;
        while(fast.next != null && fast.next.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        Node secondFirst = slow.next;
        // 断开和后面的连接
        slow.next = null;
        // 注意返回值的使用,函数返回的是排序后的链表首节点
        Node node = sortList(first);
        Node node1 = sortList(secondFirst);
        return merge(node, node1);
    }

    private static Node merge(Node node1, Node node2){
        Node dummy = new Node(1,null), tail = dummy;
        while(node1 != null && node2 != null){
            if(node1.key <= node2.key){
                tail.next = node1;
                node1 = node1.next;
            }else{
                tail.next = node2;
                node2 = node2.next;
            }
            tail = tail.next;
        }
        tail.next = (node1 == null ? node2 : node1);
        return dummy.next;
    }

	// 自测代码
    public static void main(String[] args) {
        Node dNode = new Node(1,null);
        Node cNode = new Node(2, dNode);
        Node bNode = new Node(3, cNode);
        Node aNode = new Node(4, bNode);
        Node node = sortList(aNode);
        while(node != null){
            System.out.print(node.key+" ");
            node = node.next;
        }
    }
}