数据结构 基础排序算法

#include<iostream>
using namespace std;
void out_print(int arr[],int len)
{
for(int i(0);i<len;i++)
{
cout<<arr[i]<<"\t";
}
}
void swap(int &i,int &j)//交换函数
{
int k;
k=j;
j=i;
i=k;
}
/*void Straigthinsertsort(int arr[],int len)//直接插入排序
{
for(int i(1);i<len;i++)
{
int e=arr[i];//暂存要插入的数字
for(int j=i-1;e<arr[j]&&i>=0;j--)
{
arr[j+1]=arr[j];
}
arr[j+1]=e;
}
}
//直接插入排序的时间复杂度为O(n^2)*/
/*void ShellInsert(int arr[],int len,int incr)//incr为增量
//希尔排序的思想为先将整个序列分割为若干个子序列，等序列中元素基本有序，再对全体元素进行一次插入排序
{ //cout<<incr<<"\t";
for(int i=incr;i<len;i++)
{
int e=arr[i];
for(int j=i-incr;e<arr[j]&&j>=0;j-=incr)
{
arr[j+incr]=arr[j];
}
arr[j+incr]=e;
}
}
void shellSort(int arr[],int len,int t,int inc)//t为增量长度inc为增量数组
{
for(int k(0);k<=t;k++)
{
ShellInsert(arr,len,inc);
inc--;
}
out_print(arr,len);
}*/


/*int partition(int arr[],int low,int high)//快速排序，中心思想：任选一个数字将比他大的数放在右边比他小的数放在左边，在依次对其排序
{
while(low<high)
{
while(low<high&&arr[low]<=arr[high])
high--;
swap(arr[low],arr[high]);
while(low<high&&arr[low]<=arr[high])
low++;
swap(arr[low],arr[high]);
}
return low;
}//操作结果为返回轴的位置
void quitsorthelp(int arr[],int low,int high)//完成快速排序,利用递归
{
if(low<high)
{
int par=partition(arr,low,high);
quitsorthelp(arr,low,par-1);
quitsorthelp(arr,par+1,high);
}
}
void QuitSort(int arr[],int len)
{
quitsorthelp(arr,0,len-1);
out_print(arr,len);
}*///快速排序的平均时间复杂度O(nlogn),当数组有序时为O(n^2)和冒泡排序一样


/*void SimpleSelectSort(int arr[],int len)//简单选择排序，在n-1次排序中选择最小的数作为第i个数,时间复杂度为O(n^2)
{
for(int i(0);i<len;i++)
{
int index=i;
for(int j=i+1;j<len;j++)
{
if(arr[j]<arr[index])
index=j;
}
swap(arr[i],arr[index]);
}
out_print(arr,len);
}*/




//堆排序是一种基于选择排序的先进排序算法
/*void SiftAdjust(int arr[],int low,int high)
//调整arr[low]，使其成为大顶堆
{
for(int f=low,i=2*low+1;i<high;i=2*i)
{
if(i<high&&arr[i]<arr[i+1])
i++;
if(i<high&&arr[f]>arr[i])
break;
swap(arr[f],arr[i]);
f=i;
}


}
void HeapSort(int arr[],int len)
{
for(int i=(len-2)/2;i>=0;i--)//调整堆为大顶堆，
{
SiftAdjust(arr,i,len-1);
}
//out_print(arr,len);
for(i=len-1;i>=0;i--)//交换顶堆元素与最后一个元素，重新调整堆为大顶堆
{
swap(arr[0],arr[i]);
SiftAdjust(arr,0,i-1);
}
out_print(arr,len);
}*/


//归并排序
/*void SimpleSort(int arr[],int low,int mid,int high)//将两个有序数组进行排序
{
int *elem=new int[high-low+1];
int k=0;
for(int i=low,j=mid+1;i<=mid&&j<=high;k++)
{
if(arr[i]<arr[j])
{
elem[k]=arr[i];
i++;
}else{
elem[k]=arr[j];
j++;
}
}
for(;i<=mid;i++)
{
elem[k]=arr[i];
}
for(;j<=high;j++)
{
elem[k]=arr[j];
}
for(i=low,k=0;i<=high;i++,k++)
{
arr[i]=elem[k];
}
delete []elem;
}
void SimpleMergeSort(int arr[],int low,int high)//利用递归将数组进行排序
{
if(low<high)
{
int mid=(low+high)/2;
SimpleMergeSort(arr,low,mid);
SimpleMergeSort(arr,mid+1,high);
SimpleSort(arr,low,mid,high);
}
}
void MergeSort(int arr[],int len)
//归并排序的算法是将数组先分为n个数组，进行排序，再讲n/2个有序数组进行排序，
//以此类推最后将最后0-mid,和mid+1~high这两个有序数组进行排序,时间复杂度为O(nlogn)
{
SimpleMergeSort(arr,0,len-1);
out_print(arr,len);

}*/

#include<iostream>
using namespace std;
void out_print(int arr[],int len);//输出函数
void swap(int &i,int &j);//交换函数
void Straigthinsertsort(int arr[],int len);//直接插入排序
void ShellInsert(int arr[],int len,int incr);
void shellSort(int arr[],int len,int t,int inc);//希尔排序
int partition(int arr[],int low,int high);//快速排序
void quitsorthelp(int arr[],int low,int high);
void QuitSort(int arr[],int len);
void SimpleSelectSort(int arr[],int len);//简单排序
void SiftAdjust(int arr[],int low,int high);//堆排序
void HeapSort(int arr[],int len);
void MergeSort(int arr[],int len);


int main()
{
int arr[]={12,4,5,64,6,23,7,34,19,10};
int len=sizeof(arr)/sizeof(int);
//Straigthinsertsort(arr,len);
/*int t=len/2;
int inc=t;  //inc为增量，从len/2开始，每次减一，知道减为0，shell排序的基本思想，数组越有序，时间复杂度越低，最低为O(n^1.5);
    shellSort(arr,len,t,inc);*/
//QuitSort(arr,len);
//SimpleSelectSort(arr,len);
//HeapSort(arr,len);
MergeSort(arr,len);

return 0;
}