排序算法（二）—归并排序（Merge sort)

Merge sort首先将需要排序的序列拆分成单独的可排序对象，然后将这些可排序对象两两进行归并，直到把它们再合并为一个排序好的序列为止。

Merge sort不是in place排序，但是将Merge sort应用于链表（list)和数组的时候，两者的空间复杂度是不同的。应用于链表的时候空间复杂度更低。因此Merge sort更适用于链表。

本文采用非递归的方式来实现Merge sort在队列上的操作（队列其实就是一种被限制了操作的链表，可以理解为残废了的链表）。基本思想是将待排序的队列首先拆分成队列的队列，初始时每个队列只有1个可排序的对象，然后将相邻的两个队列merge，merge后将产生一个新的队列，将该新队列加入到刚才队列的队列的队尾，然后队头接着之前的merge操作。重复这个过程依次merge下去，直到队列的队列中只有一个队列为止。这时就完成了merge sort。这么介绍每部分的代码：

（1）首先定义队列（Queue）的接口：

/* Queue.java */

package list;

public interface Queue {

/**
*  size() returns the size of this Queue.
*  @return the size of this Queue.
*  Performance:  runs in O(1) time.
**/
public int size();

/**
*  isEmpty() returns true if this Queue is empty, false otherwise.
*  @return true if this Queue is empty, false otherwise.
*  Performance:  runs in O(1) time.
**/
public boolean isEmpty();

/**
*  enqueue() inserts an object at the end of the Queue.
*  @param item the item to be enqueued.
**/
public void enqueue(Object item);

/**
*  dequeue() removes and returns the object at the front of the Queue.
*  @return the item dequeued.
*  @throws a QueueEmptyException if the Queue is empty.
**/
public Object dequeue() throws QueueEmptyException;

/**
*  front() returns the object at the front of the Queue.
*  @return the item at the front of the Queue.
*  @throws a QueueEmptyException if the Queue is empty.
**/
public Object front() throws QueueEmptyException;

}

（2）定义Queue接口的实现类LinkedQueue:

/* LinkedQueue.java */

package list;

public class LinkedQueue implements Queue {

private SListNode head;
private SListNode tail;
private int size;

/**
*  LinkedQueue() constructs an empty queue.
**/
public LinkedQueue() {
size = 0;
head = null;
tail = null;
}

/**
*  size() returns the size of this Queue.
*  @return the size of this Queue.
*  Performance:  runs in O(1) time.
**/
public int size() {
return size;
}

/**
*  isEmpty() returns true if this Queue is empty, false otherwise.
*  @return true if this Queue is empty, false otherwise.
*  Performance:  runs in O(1) time.
**/
public boolean isEmpty() {
return size == 0;
}

/**
*  enqueue() inserts an object at the end of the Queue.
*  @param item the item to be enqueued.
**/
public void enqueue(Object item) {
if (head == null) {
head = new SListNode(item);
tail = head;
} else {
tail.next = new SListNode(item);
tail = tail.next;
}
size++;
}

/**
*  dequeue() removes and returns the object at the front of the Queue.
*  @return the item dequeued.
*  @throws a QueueEmptyException if the Queue is empty.
**/
public Object dequeue() throws QueueEmptyException {
if (head == null) {
throw new QueueEmptyException();
} else {
Object o = head.item;
head = head.next;
size--;
if (size == 0) {
tail = null;
}
return o;
}
}

/**
*  front() returns the object at the front of the Queue.
*  @return the item at the front of the Queue.
*  @throws a QueueEmptyException if the Queue is empty.
**/
public Object front() throws QueueEmptyException {
if (head == null) {
throw new QueueEmptyException();
} else {
return head.item;
}
}

/**
*
*  nth() returns the nth item in this LinkedQueue.
*    Items in the queue are numbered from 1.
*  @param n the number of the item to return.
*/
public Object nth(int n) {
SListNode node = head;
for (; n > 1; n--) {
node = node.next;
}
return node.item;
}

/**
*  append() appends the contents of q onto the end of this LinkedQueue.
*    On completion, q is empty.
*  @param q the LinkedQueue whose contents should be appended onto this
*    LinkedQueue.
**/
public void append(LinkedQueue q) {
if (head == null) {
head = q.head;
} else {
tail.next = q.head;
}
if (q.head != null) {
tail = q.tail;
}
size = size + q.size;
q.head = null;
q.tail = null;
q.size = 0;
}

/**
*  toString() converts this queue to a String.
**/
public String toString() {
String out = "[ ";
try {
for (int i = 0; i < size(); i++) {
out = out + front() + " ";
enqueue(dequeue());
}
} catch (QueueEmptyException uf) {
System.err.println("Error:  attempt to dequeue from empty queue.");
}
return out + "]";
}
}

（3）将一个LinkedQueue拆分成队列的队列的方法：

public static LinkedQueue makeQueueOfQueues(LinkedQueue q) {
LinkedQueue queues = new LinkedQueue();
while(!q.isEmpty()){
LinkedQueue newQueue = new LinkedQueue();
try {
newQueue.enqueue(q.dequeue());
queues.enqueue(newQueue);
} catch (QueueEmptyException e) {
e.printStackTrace();
}
}
return queues;
}

（4）merge两个队列的方法，这里要注意处理当只剩下一个队列还有元素的情况：

public static LinkedQueue mergeSortedQueues(LinkedQueue q1, LinkedQueue q2) {
LinkedQueue sortedQueue = new LinkedQueue();
while(!q1.isEmpty() && !q2.isEmpty()){
if(((Comparable) q1.nth(1)).compareTo((Comparable)q2.nth(1)) <= 0){
try {
sortedQueue.enqueue(q1.dequeue());
} catch (QueueEmptyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else{
try {
sortedQueue.enqueue(q2.dequeue());
} catch (QueueEmptyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
if(q1.isEmpty() && !q2.isEmpty()){
sortedQueue.append(q2);
}else if(q2.isEmpty() && !q1.isEmpty()){
sortedQueue.append(q1);
}
return sortedQueue;
}

（5）最后是mergeSort()方法：

public static void mergeSort(LinkedQueue q) {
if(q.isEmpty()){
return;
}
LinkedQueue queues = makeQueueOfQueues(q);
while(queues.size() != 1){
try {
LinkedQueue q1 = (LinkedQueue) queues.dequeue();
LinkedQueue q2 = (LinkedQueue) queues.dequeue();
queues.enqueue(mergeSortedQueues(q1,q2));
} catch (QueueEmptyException e) {
e.printStackTrace();
}
}
q.append(queues);
}

这里很有意思的是这种实现方法的空间复杂度，首先假设待排序的LinkedQueue q有n个对象，因此它的空间复杂度是O（n）。将q拆分成队列的队列queues后，这时q被清空，已经没有元素了，元素都跑到了queues里，这时queues的空间复杂度是O（n），整个程序的空间复杂度也是O（n）。随着queues的元素出队列merge，queues的元素在减少，但是减少这部分被q1和q2接收了，而当merge后新的queue又加到了queues的后边，q1和q2被清空，因此整个过程程序的空间复杂度都是O（n）。而如果是数组的话就做不到这一点。

Merge sort的时间复杂度比较容易得到，根据递归树来计算，这里顺便提一下递归树的计算，merge sort 的每一次都是cn，因此每一次的工作量都是相同的，有些算法在用递归树分析时，工作量可能都集中在顶层，而有些又集中在底层。如图：



本文要点：

（1）Merge sort用在链表和数组的情况下空间复杂度不同，具体分析过程文中已提到；

（2）非递归的merge sort链表的过程，本文是以队列为例的。

（3）在将q拆分成队列的队列queues时，其实这时还是一个链表，只是链表中的元素类型变成了LinkedQueue，但是实际存储的对象未变。其实这个过程完全可以直接运用链表来完成，链表中的元素起初都只是包含一个对象，而随着归并的进行，每个元素包含的对象在增加，从而变成了每个元素是一个链表。之所以采用队列，就是在表述上会更清晰一些。

（4）可以通过递归树看到一个算法的时间复杂度的分布情况。