归并排序:
归并排序的思想:
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];
}
}
}