归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

再来看归并排序

描述：

基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

图示：



算法：

package com.zq.algorithm.sort;

/**
* Created by zhengshouzi on 2015/11/2.
*/
public class MergeSort {
public static void main(String[] args) {

int[] a = {10, 4, 6, 3, 8, 2, 5, 7};

mergeSort(a, 0, a.length - 1);

//输出最后结果
for (int i = 0; i < a.length; i++) {
System.out.print(" " + a[i]);
}
}

/**
* 递归方法，用来分解问题，
* @param a     源数组
* @param left  每次分解的序列的左边界
* @param right 每次分解的序列的的右边界
*/
public static void mergeSort(int[] a, int left, int right) {
//定义中间值
int middle;

//定义递归结束条件，，当左边界< 右边界的时候才递归，左边界等于右边界 时候表示这一次只归并一个元素，一个元素当然是有序的，不用做处理直接返回上一层
if (left < right) {
//求出中间值
middle = (left + right) / 2;
//递归调用此方法，使原来的大问题，分解成最小的一个元素有序的小问题，
mergeSort(a, left, middle);
mergeSort(a, middle + 1, right);
//当左边和右边都有序了，那么就合并左右两边的序列，使序列整体有序
mergeArray(a, left, middle, right);
}

}
/**
*   归并两个连续的有序的序列
* @param a 源数组
* @param first 序列的开始下标
* @param middle 中间下标
* @param last 结束下标
*/
public static void mergeArray(int[] a, int first, int middle, int last) {

//必须要一个temp数组，长度为每次需要归并的序列的长度，也就是动态变化的，最大为整个a 数组的长度（最后一个合并）
int[] temp = new int[last - first + 1];
//定义下标变量
int index1 = first;
int index2 = middle + 1;
int k = 0;
//将两个有序的序列，合并成一个有序的序列，放入temp数组中，循环退出条件是：有一个序列比较完了，那么这时候将另外一个有序序列中所有元素依次放入temp中
while (index1 <= middle && index2 <= last) {
//依次比较两个序列中元素谁小，谁就放入temp中，
if (a[index1] <= a[index2]) {
temp[k++] = a[index1++];
} else {
temp[k++] = a[index2++];
}
}

//将上面没有比较晚的，有序序列中所有元素依次放入temp中
while (index1 <= middle)
temp[k++] = a[index1++];
while (index2 <= last)
temp[k++] = a[index2++];

//temp必是有序的，将temp中的元素，写到原来的a数组中的对应位置（从first 开始的temp.length 个长度）
for (int i = 0; i < temp.length; i++) {
a[first + i] = temp[i];
//System.out.print(" " + temp[i]);
}
//System.out.println();
}
}

上面的代码都配有详细的注释，不懂的可以评论给我。

下面的代码，我打印出了整个分解和合并的过程，如下图

package com.zq.algorithm.sort;

/**
* Created by zhengshouzi on 2015/11/2.
*/
public class MergeSort {
public static void main(String[] args) {

int[] a = {10, 4, 6, 3, 8, 2, 5, 7};

mergeSort1(a, 0, a.length - 1);

//输出最后结果
for (int i = 0; i < a.length; i++) {
System.out.print(" " + a[i]);
}
}

public static void mergeSort1(int[] a, int left, int right) {
//定义中间值
int middle;

System.out.print("分解：");
for (int i = left; i <= right; i++) {
System.out.print( "  "+ a[i]);
}
System.out.println();

//定义递归结束条件，，当左边界< 右边界的时候才递归，左边界等于右边界 时候表示这一次只归并一个元素，一个元素当然是有序的，不用做处理直接返回上一层
if (left < right) {
//求出中间值
middle = (left + right) / 2;

//递归调用此方法，使原来的大问题，分解成最小的一个元素有序的小问题，
mergeSort1(a, left, middle);
mergeSort1(a, middle + 1, right);
//当左边和右边都有序了，那么就合并左右两边的序列，使序列整体有序
mergeArray1(a, left, middle, right);
}else {
//System.out.println("叶子节点：" +a[left]);
}

}

public static void mergeArray1(int[] a, int first, int middle, int last) {

//必须要一个temp数组，长度为每次需要归并的序列的长度，也就是动态变化的，最大为整个a 数组的长度（最后一个合并）
int[] temp = new int[last - first + 1];
//定义下标变量
int index1 = first;
int index2 = middle + 1;
int k = 0;
//将两个有序的序列，合并成一个有序的序列，放入temp数组中，循环退出条件是：有一个序列比较完了，那么这时候将另外一个有序序列中所有元素依次放入temp中
while (index1 <= middle && index2 <= last) {
//依次比较两个序列中元素谁小，谁就放入temp中，
if (a[index1] <= a[index2]) {
temp[k++] = a[index1++];
} else {
temp[k++] = a[index2++];
}
}

//将上面没有比较晚的，有序序列中所有元素依次放入temp中
while (index1 <= middle)
temp[k++] = a[index1++];
while (index2 <= last)
temp[k++] = a[index2++];

//temp必是有序的，将temp中的元素，写到原来的a数组中的对应位置（从first 开始的temp.length 个长度）
System.out.print("归并：");
for (int i = 0; i < temp.length; i++) {
a[first + i] = temp[i];
System.out.print(" " + temp[i]);
}
System.out.println();
System.out.println("--------------------------------------------");
}
}

上面的数字，是计算机执行归并过程的调用执行顺序，对于理解递归很有帮助

归并排序的效率是比较高的，设数列长为N，将数列分开成小数列一共要lgN（计算机里面表示以2为底N的对数）步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(N*logN)

为什么是lgN
??

设需要X步，最后才能分解成一个元素，那么(N/2的x次方) = 1, 解得X = lgN;