Java实现单向链表的归并排序

Java实现单向链表的归并排序 
作者是 在线疯狂 发布于 2014年11月21日 在 Java, 他山之石, 数据结构.

由于链表（LinkedList）不支持随机访问（Random Access），只允许顺序访问，因此对于链表的O(logn)时间复杂度的排序算法不可以采用诸如快速排序等基于随机访问的排序算法，而归并排序可以满足这一需求。

归并排序是分治法（Divide and Conquer）的典型应用，其伪代码如下：

merge_sort(list) {
split list into two halfs, say first and second ;
merge_sort(firstHalf);
merge_sort(secondHalf);
merge(firstHalf,secondHalf);
}

1
2
3
4
5
6

下面的Java代码实现了对单链表（singly linked list）的归并排序，代码实现优美，可读性强，具有较高的参考价值：

// The main function
public Node merge_sort(Node head) {
if (head == null || head.next == null) {
return head;
}
Node middle = getMiddle(head); // get the middle of the list
Node sHalf = middle.next;
middle.next = null; // split the list into two halfs

return merge(merge_sort(head), merge_sort(sHalf)); // recurse on that
}

// Merge subroutine to merge two sorted lists
public Node merge(Node a, Node b) {
Node dummyHead, curr;
dummyHead = new Node();
curr = dummyHead;
while (a != null && b != null) {
if (a.val <= b.val) {
curr.next = a;
a = a.next;
} else {
curr.next = b;
b = b.next;
}
curr = curr.next;
}
curr.next = (a == null) ? b : a;
return dummyHead.next;
}

// Finding the middle element of the list for splitting
public Node getMiddle(Node head) {
if (head == null) {
return head;
}
Node slow, fast; //“快慢指针”
slow = fast = head;
while (fast.next != null && fast.next.next != null) {
slow = slow.next;
fast = fast.next.next;
}
return slow;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1617
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

链表节点Node的定义如下：

public class Node {
public Node next;
public int val;
}

1
2
3
4

原文链接：http://www.dontforgettothink.com/2011/11/23/merge-sort-of-linked-list/