归并排序(Merging Sort)：归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
原理：假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n除以2向上取整个长度为2或1的有序子序列；两两归并，直到得到一个长度为n的有序序列为止。
|
#include<iostream>
using namespace std;
//归并排序,先数组细分为单个，在合并
int mergeArr(int* arr,int first,int mid,int last);
int mergeSort(int* arr,int first,int last); //递归实现
int mergeSortIterator(int* arr,int first,int last); //非递归实现
void swap(int& elem1,int& elem2);
void test();
void printArr(int* arr,int length);
int mergeArr(int* arr,int first,int mid,int last)
{
if(NULL==arr||first>last||first>mid||mid>last||first<0||mid<0||last<0)
return -1;
int len = last - first +1;
int* tmpArr = new int[len]();
int firIdx = first,lasIdx = mid + 1;
int idx = 0;
while(firIdx<=mid&&lasIdx<=last)
{
if(arr[firIdx]<arr[lasIdx])
tmpArr[idx++] = arr[firIdx++];
else
tmpArr[idx++] = arr[lasIdx++];
}
while(firIdx<=mid)
tmpArr[idx++] = arr[firIdx++];
while(lasIdx<=last)
tmpArr[idx++] = arr[lasIdx++];
for(int iidx=first,idx=0;iidx<=last;++iidx)
arr[iidx] = tmpArr[idx++];
delete []tmpArr;
return 0;
}
int mergeSort(int* arr,int first,int last)
{
if(NULL==arr||first<0||last<0||first>last)
return -1;
int mid = (first + last)/2;
if(first<last) //划分为只有一个元素
{
mergeSort(arr,first,mid);
mergeSort(arr,mid+1,last);
}
//合并
mergeArr(arr,first,mid,last);
return 0;
}
int mergeSortIterator(int* arr,int first,int last)
{
if(NULL==arr||first<0||last<0||first>last)
return -1;
//非递归，直接合并
for(int idx=1;idx<=last;idx*=2) //都是两两合并，所以乘以2，最初从1开始，表示数组都划分为1的单个数组
{
int firstIdx = 0;
while(firstIdx+idx<=last)
{
int mid = firstIdx + idx -1;
//last有特殊情况，比如数组奇数个，最后会剩下一个元素
int lastIdx = mid + idx <= last ? mid + idx : last;
mergeArr(arr,firstIdx,mid,lastIdx);
firstIdx = lastIdx + 1; //开始合并下一个子序列
}
}
return 0;
}
|
void printArr(int* arr,int length)
{
if(NULL==arr||length<=0)
return ;
for(int idx=0;idx!=length;++idx)
{
cout<<arr[idx]<<" ";
}
cout<<endl;
}
void test()
{
int arr[] = {6,5,3,1,8,7,2,4};
printArr(arr,8);
mergeSort(arr,0,7);
/*mergeSortIterator(arr,0,7);*/
printArr(arr,8);
cout<<endl;
int arr1[] = {1,2,0,-1,5,6,8,3};
printArr(arr1,8);
mergeSort(arr1,0,7);
/*mergeSortIterator(arr1,0,7);*/
printArr(arr1,8);
cout<<endl;
int arr2[] = {2,2,2,2};
printArr(arr2,4);
mergeSort(arr2,0,3);
//mergeSortIterator(arr2,0,3);
printArr(arr2,4);
cout<<endl;
int arr3[] = {2,4,1};
printArr(arr3,3);
mergeSort(arr3,0,2);
/*mergeSortIterator(arr3,0,2);*/
printArr(arr3,3);
cout<<endl;
int arr5[] = {1,2,3,4,5,6,7,8};
printArr(arr5,8);
mergeSort(arr5,0,7);
/*mergeSortIterator(arr5,0,7);*/
printArr(arr5,8);
cout<<endl;
int* arr6 = NULL;
printArr(arr6,4);
mergeSort(arr6,0,3);
/*mergeSortIterator(arr6,0,3);*/
printArr(arr6,4);
cout<<endl;
}
int main()
{
test();
system("pause");
}
|
//归并排序，原地归并，空间复杂度O(1)
|
//归并排序，一般的空间复杂度都是O(n)，现在要O(1)
#include<iostream>
using namespace std;
void swap(int& a,int& b)
{
int tmp = a;
a = b;
b = tmp;
return ;
}
void reverse(int* arr,int len) //len个元素的数组逆序
{
if(NULL==arr)
return ;
int first = 0,end = len-1;
while(first<end)
{
swap(arr[first++],arr[end--]);
}
return ;
}
void printArr(int* arr,int len)
{
if(NULL==arr)
return ;
for(int idx=0;idx!=len;++idx)
{
cout<<arr[idx]<<" ";
}
cout<<endl;
return;
}
|
void moveLeft(int* arr,int len,int cnt) //arr数组，长度len，左移cnt个元素
{
if(NULL==arr||len<=0)
return ;
reverse(arr,cnt); // 1 2 3 4 5 ,左移3个位置，arr，5,3
reverse(arr+cnt,len-cnt);
reverse(arr,len);
}
void mergeArr(int* arr,int first,int mid,int end)
{
if(NULL==arr||first>end||mid>end)
return ;
int second = mid + 1;
while(first<=mid&&second<=end)
{
int secondLow = 0;
while( first<=mid && arr[first]<=arr[second] )
++first;
while( second<=end && arr[second]<=arr[first] )
{
++second;
++secondLow;
}
moveLeft(arr+first,second-first,second - first - secondLow);
first += secondLow;
}
return ;
}
void mergeSort(int* arr,int first,int end)
{
if(NULL==arr)
return;
if(first<end)
{
int mid = (first + end)/2;
mergeSort(arr,first,mid);
mergeSort(arr,mid+1,end);
//归并
mergeArr(arr,first,mid,end);
}
}
int main(int argc,char** argv)
{
int arr[] = {6,4,3,1,7,8,2,9,5,0};
mergeSort(arr,0,9);
printArr(arr,10);
system("pause");
}
|
