【C++】各种排序算法的实现（基于数组的实现）

C++基于数组的各种排序算法的实现

包括：
插入排序、折半插入排序、希尔排序、快速排序、直接选择排序、堆排序、归并排序

#include<iostream>
#include<cstring>
using namespace std;

/**************************************/
//插入排序 O(n^2) 稳定
void InsertSort(int a[], int len){
for(int i=0;i<len;i++){
int temp=a[i];
for(int j=i-1;j>=0;j--){
if(temp<a[j]){
a[j+1]=a[j];
a[j]=temp;
}
else break;
}
}
}
/**************************************/

/**************************************/
//折半插入排序 O(nlog2(n)) 稳定
int low,high,middle;
void BinaryInsertSort(int a[], int len){
for(int i=0;i<len;i++){
int temp=a[i];
low=0;high=i-1;
while(low<=high){
middle=(low+high)/2;
if(temp<a[middle]){
high=middle-1;
}
else{
low=middle+1;
}
}
for(int k=i;k>low;k--){
a[k]=a[k-1];
}
a[low]=temp;
}
}
/**************************************/

/**************************************/
//希尔排序 速度很难定量 但是效率挺高的 不稳定的算法
void Shellsort(int a[], int len){
int gap=len-1; //初始增量
bool flag=0;
while(gap>=1){
if(gap==1) flag=1;
for(int i=0;i<len;i++){
if(i+gap<len){
if(a[i]>a[i+gap]){
int temp=a[i];
a[i]=a[i+gap];
a[i+gap]=temp;
}
}
else break;
}
gap=gap/3+1;
if(flag) break;
}
}
/**************************************/

# define MAX 6

/**************************************/
//快速排序
void QuickSort(int a[], int len){
if(len>1){
int temp=a[0], pivotpos=0;
int left[MAX], l=0;
int right[MAX], r=0;
for(int i=1;i<len;i++){
if(a[i]>=temp){
right[r++]=a[i];
pivotpos++;
}
else{
left[l++]=a[i];
}
}

QuickSort(left,l);
QuickSort(right,r);

for(int i=0;i<len;i++){
if(i<l){
a[i]=left[i];
}
else if(i>l){
a[i]=right[i-l-1];
}
else{
a[i]=temp;
}
}

}
}

/*
改进方法：
插入排序对基本有序的序列具有很高的效率，
所以在左右划分以后，如果序列的长度比较小，
可以先不排列（长度一般在5-25），直接放着，
最后用插入排序，这种混合算法效率更高

*/

/**************************************/

/***************************************/
//直接选择排序
//适用于的元素规模很大的序列，即移动操作十分耗时的操作
//该算法的移动操作比其他算法少
void SelectSort(int a[], int len){
for(int i=0;i<len;i++){
int index=i;
int min=a[i];
for(int j=i;j<len;j++){
if(a[j]<min){
min=a[j];
index=j;
}
}
if(index!=i){
int temp=a[i];
a[i]=a[index];
a[index]=temp;
}
}
}
/***************************************/

/***************************************/
/* 堆排序
最大堆（升序） 不稳定排序 */
void heapSort(int a[],int len){
for(int i=len;i>0;i--){
int temp;
for(int j=i/2-1;j>=0;j--){
if(2*j+1<i)
if(a[2*j+1]>=a[j]){
temp=a[2*j+1];
a[2*j+1]=a[j];
a[j]=temp;
}
if(2*j+2<i)
if(a[2*j+2]>=a[j]){
temp=a[2*j+2];
a[2*j+2]=a[j];
a[j]=temp;
}
}
temp=a[0];
a[0]=a[i-1];
a[i-1]=temp;
}
}
/***************************************/

/***************************************/
/*归并排序*/
void mergeSort(int a[],int len){
if(len<=1) return;
if(len==2){
if(a[0]>a[1]){
int temp=a[0];
a[0]=a[1];
a[1]=temp;
}
return;
}

//分 ：
int b[MAX],c[MAX];
int p=0,q=0;
for(int i=0;i<len;i++){
if(i<=len/2){
b[p++]=a[i];
}
else{
c[q++]=a[i];
}
}

mergeSort(b,p);
mergeSort(c,q);

//合并（治） ：
int i=0,j=0,k=0;
while(i<p&&j<q){
if(b[i]<=c[j]){
a[k++]=b[i++];
}
else{
a[k++]=c[j++];
}
}

while(i<p){
a[k++]=b[i++];
}
while(j<q){
a[k++]=c[j++];
}
}
/***************************************/

int main(){//测试部分
int a[]={21,25,49,25,16,8};
mergeSort(a,6); //更改此函数进行测试
for(int i=0;i<6;i++){
cout<<a[i]<<" ";
}
cout<<endl;
}