归并排序复习

归并排序：

归并排序的思想：

1. 将待排序的线性表不断地切分成若干个子表，直到每个子表只包含一个元素，这时，可以认为只包含一个元素的子表是有序表。
2. 将子表两两合并，每合并一次，就会产生一个新的且更长的有序表，重复这一步骤，直到最后只剩下一个子表，这个子表就是排好序的线性表。

这里面就用到了非常重要的分治思想，把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，最后将子问题的解合并，就得到了原问题的解。

 

实现方式:

两种实现方式

1. 自顶向下

自顶向下的思想就是把大表逐步进行切分操作，直到每个子表只有两个元素，然后开始进行两两合并；可以用递归的方式来实现；

2. 自底向上

自底向上的思想就是，进行分解，直接从线性表中的单个元素开始，进行两两合并，然后再以每两个元素为单位，进行两两合并……直到最后只剩下一个线性表。这种方式跳过了分解的步骤，操作步骤少了很多，而且在用代码实现时，采用的是迭代而不是递归的方式，空间复杂度也少了很多。

 

代码实现（C++）：

#include <iostream>

using namespace std;

/*合并Array[low, mid)和Array[mid, high)
  合并前应保证Array[low, mid)和Array[mid, high)中的元素都是有序的*/
void merge(int* Array, int low, int mid, int high){
    int* A = Array + low; //合并后的向量A[0, high - low) = _elem[low, high)
    int lb = mid - low;
    int* B = new int[lb]; //前子向量B[0, lb) = _elem[low, mid)
    for (int i = 0; i < lb; B[i] = A[i++]); //复制前子向量B
    int lc = high - mid;
    int* C = Array + mid; //后子向量C[0, lc) = _elem[mid, high)

    /*i, j, k分别指向A, B, C中的元素*/
    for (int i = 0, j = 0, k = 0; (j < lb) || (k < lc);) { //B[j]和C[k]中小者转至A的末尾
        if (j < lb && k < lc) //如果j和k都没有越界，那么就选择B[j]和C[k]中的较小者放入A[i]
            A[i++] = B[j] < C[k] ? B[j++] : C[k++];
        if (j < lb && lc <= k) //如果j没有越界而k越界了，那么就将B[j]放入A[i]
            A[i++] = B[j++];
        if (lb <= j && k < lc) //如果k没有越界而j越界了，那么就将C[k]放入A[i]
            A[i++] = C[k++];
    }

    delete[] B; //释放临时空间B
}

/*自底向上，迭代
  Array：待排序的数组首地址
  low：待排序的范围的下界
  high：待排序的范围的上界的后一个位置
  比如你要对数组Array[0]~Array[5]进行排序，那么low=0，high=6*/
void mergeSort(int* Array, int low, int high)
{
    int step = 1;
    while (step < high) {
        for (int i = low; i < high; i += step << 1) {
            int lo = i, hi = (i + (step << 1)) <= high ? (i + (step << 1)) : high; //定义二路归并的上界与下界 
            int mid = i + step <= high ? (i + step) : high;
            merge(Array, lo, mid, hi);
        }

        //将i和i+step这两个有序序列进行合并
        //序列长度为step
        //当i以后的长度小于或者等于step时，退出
        step <<= 1;//在按某一步长归并序列之后，步长加倍
    }
}

/*自顶向下，递归
  Array：待排序的数组首地址
  low：待排序的范围的下界
  high：待排序的范围的上界的后一个位置
  比如你要对数组Array[0]~Array[5]进行排序，那么low=0，high=6*/
void mergeSort_Recursive(int* Array, int low, int high) {
    if (low + 1 < high) { //当子数组的长度大于1时，不断对数组进行分解
        int mid = low + (high - low + 1) / 2; //将数组分解成Array[low, mid)和A[mid, high)，圆括号表示开区间，即数组中不包含此元素
        mergeSort_Recursive(Array, low, mid);
        mergeSort_Recursive(Array, mid, high);
        merge(Array, low, mid, high); //合并Array[low, mid)和A[mid, high)
    }
}

int main() {
    int A[8] = { 6, 3, 2, 7, 1, 5, 8, 4 };

    mergeSort(A, 0, 8);
    //mergeSort_Recursive(A, 0, 8);
    for (int i = 0; i < 8; i++) {
        cout << A[i] << " ";
    }
    system("pause");
    return 0;
}

  代码实现（java）：

对于给定的一组记录（假设有n个记录），首先将每两个相邻的长度为1的子序列进行归并，得到n/2(向上取整)个长度为2或者1的有序子序列，再将其两两归并，反复执行此过程，直到得到一个有序序列。

public void main(){
  int i=0; 
  int a[] = {5,4,9,8,7,6,0,1,3,2};
  int len = a.length;
  MergeSort(a,0,len-1);
  for(i=0; i<len; i++){
	System.err.print(a[i]+" ");
  }
}

// 递归调用
private void MergeSort(int[] a, int p, int r) {
		if(p<r){
			int q = (p+r)/2;
            //p表示从子序列的哪个索引开始，q表示子序列中间的位置
			MergeSort(a,p,q);
			MergeSort(a,q+1,r);
			Merge(a,p,q,r);
		}
}

// 合并方法
private void Merge(int[] a, int p, int q, int r) {
        // n1和n2分别表示左边序列和右边序列的长度。左边从p开始包括q，右边从q+1开始
		int n1 = q-p+1;
		int n2 = r-q;
		int L[] = new int[n1];
		int R[] = new int[n2];
        // k用来表示当前遍历的数组a的索引
		int i=0,j=0,k=0;
        // 分别给L和R赋值
		for(i=0,k=p; i<n1; i++,k++){
			L[i] = a[k];
		}
        // 从右边开始
		for(j=0,k=q+1; j<n2; j++,k++){
			R[j] = a[k];
		}
        // 比较大小,从小到大排列
		for(i=0,j=0,k=p; i<n1&&j<n2; k++){
			if(L[i] > R[j]){
				a[k] = R[j];
				j++;
			}else{
				a[k] = L[i];
				i++;
			}
		}
        // 将两个数组中剩下的数放到a中
		if(i<n1){
			for(j=i; j<n1; j++,k++){
				a[k] = L[j];
			}
		}
		if(j<n2){
			for(i=j; i<n2; i++,k++){
				a[k] = R[i];
			}
		}
}