数据结构——八大排序算法c语言实现
数据结构——八大排序算法c语言实现
插入，希尔，选择，冒泡，堆排，快排，归并，计数
c语言实现，并分析其时间，空间复杂度以及稳定性
#include
if(array[begin]>array[end])
return begin;
else
return end;
}
} else{
//begin>=mid
if(array[mid]>array[end])
return mid;
else{
//begin>=mid end>=mid
if(array[begin]<array[end] )
return begin;
else
return end;
}
}
}
int partion(int* array, int begin, int end){
//挖坑法
int mid=getMid(array,begin,end);
Swap(array,mid,begin);//优化，防止最坏情况出现
int key=array[begin];
while(begin<end){
while(begin<end&&array[end]>=key)
end--;
array[begin]=array[end];
while(begin<end&&array[begin]<=key)
begin++;
array[end]=array[begin];
}
array[begin]=key;
return begin;
}
int partion2(int* array, int begin, int end){
//hora
int key=array[begin];
int start=begin;
while(begin<end){
while(begin<end&&array[end]>=key)
end--;
while(begin<end&&array[begin]<=key)
begin++;
Swap(array,begin,end);
}
Swap(array,begin,start);
return begin;
}
int partion3(int* array, int begin, int end){
//前后指针法
int prev=begin;//最后一个小于基准值的位置
int cur=prev+1;//新发现的下一个小于基准值的位置
int key=array[begin];
while(cur<=end){
if(array[cur]<key&&++prev!=cur)
Swap(array,cur,prev);
cur++;
}
Swap(array,begin,prev);
return prev;
}
void quickSort(int* array, int begin, int end){
if(begin>=end)
return;
int keyPos=partion(array,begin,end);
quickSort(array,begin,keyPos-1);
quickSort(array,keyPos+1,end);
}
//栈实现非递归
void quickSortNoR(int* array,int n){
Stack st;
stackInit(&st,10);
if(n>1){
stackPush(&st,n-1);
stackPush(&st,0);
}
while(stackEmpty(&st)!=1){
int begin=stackTop(&st);
stackPop(&st);
int end=stackTop(&st);
stackPop(&st);
//划分
int keyPos=partion(array,begin,end);
//子区间入栈：先入右
//右区间：keyPos+1--end
if(keyPos+1<end){
stackPush(&st,end);
stackPush(&st,keyPos+1);
}
//左区间：begin--keyPos
if(begin<keyPos-1){
stackPush(&st,keyPos-1);
stackPush(&st,begin);
}
}
}
//用队列实现非递归
void quickSortNoR2(int* array,int n){
Queue q;
queueInit(&q);
if(n>1){
queuePush(&q,0);
queuePush(&q,n-1);
}
while(queueEmpty(&q)!=1){
int begin=queueFront(&q);
queuePop(&q);
int end=queueFront(&q);
queuePop(&q);
//划分
int keyPos=partion(array,begin,end);
//队列保存子区间，先入左区间
// 左区间 begin--keyPos-1
if(begin<keyPos-1){
queuePush(&q,begin);
queuePush(&q,keyPos-1);
}
//右区间 keyPos+1--end
if(keyPos+1<end){
queuePush(&q,keyPos+1);
queuePush(&q,end);
}
}
}
//归并排序
//时间复杂度 ：O(nlgn)
//空间复杂度：O(n)
//稳定性：稳定
//合并两个有序的子区间：begin--mid mid+1--end
void merge(int*array,int* tmp,int begin,int mid,int end){
int idx=0,i;
int begin1=begin,end1=mid,begin2=mid+1,end2=end;
while(begin1<=end1&&begin2<=end2){
if(array[begin1]<array[begin2])
tmp[idx++]=array[begin1++];
else
tmp[idx++]=array[begin2++];
}
while(begin1<=end1)
tmp[idx++]=array[begin1++];
while(begin2<=end2)
tmp[idx++]=array[begin2++];
for(i=0;i<idx;i++){
//从临时数组拷贝到原数组
array[i+begin]=tmp[i];
}
}
void mergeSortR(int* array,int* tmp,int begin,int end){
if(begin<end){
int mid=begin+(end-begin)/2;
//首先保证子区间是否有序
mergeSortR(array,tmp,begin,mid);
mergeSortR(array,tmp,mid+1,end);
merge(array,tmp,begin,mid,end);
}
}
void mergeSort(int* array,int n){
if(n>1){
int* tmp=(int*)malloc(sizeof(int)*n);
mergeSortR(array,tmp,0,n-1);
free(tmp);
}
}
//非递归实现
void mergeSortNoR(int* array,int n){
if(n<=1)
return;
int* tmp=(int*)malloc(sizeof(int)*n);
int k=1,i;
while(k<n){
//多轮的归并
for(i=0;i<n;i+=2*k){
int begin=i;
int mid=i+k-1;
if(mid>=n-1)
continue;
int end=i+2*k-1;
if(end>=n)
end=n-1;
merge(array,tmp,begin,mid,end);
}
k*=2;
}
}
//计数排序
//时间复杂度 ：O(max(n,range))
//空间复杂度：O(range)
//稳定性：一般教材上认为是稳定
void countSort(int* array,int n){
//统计范围
int i;
int min=array[0],max=array[0];
for(i=1;i<n;i++){
if(array[i]<min)
min=array[i];
if(array[i]>max)
max=array[i];
}
int range=max-min+1;
int* countArr=(int*)malloc(sizeof(int)*range);
memset(countArr,0,sizeof(int)*range);
for(i=0;i<n;i++){
countArr[array[i]-min]++;
}
int idx=0;
for(i=0;i<range;i++){
while(countArr[i]--){
array[idx++]=i+min;
}
}
free(countArr);
}