数据结构——八大排序算法c语言实现
插入，希尔，选择，冒泡，堆排，快排，归并，计数
c语言实现，并分析其时间，空间复杂度以及稳定性
#include<stdio.h>
#include<stdlib.h>
#include"Sort.h"
#include<memory.h>
void Swap(int* array, int i, int j){
int tmp=array[i];
array[i]=array[j];
array[j]=tmp;
}
//插入排序
//时间复杂度 ：最坏O(n^2) 最好O(n) 平均O(n^2)
//空间复杂度：O(1)
//稳定性：稳定
void insertSort(int* array, int n){
int i;
for(i=0;i<n-1;i++){
int end=i;
int key=array[end+1];
while(end>=0&&array[end]>key){
array[end+1]=array[end];
end--;
}
array[end+1]=key;
}
}
//希尔排序
//时间复杂度 ：最坏O(n^1.3) 最好O(n) 平均O(n^1.3)
//空间复杂度：O(1)
//稳定性：不稳定
void shellSort(int* array, int n){
int i,step=n/2;
while(step>=1){
for(i=0;i<n-step;i++){
int end=i;
int key=array[end+step];
while(end>=0&&array[end]>key){
array[end+step]=array[end];
end-=step;
}
array[end+step]=key;
}
step/=2;
}
}
//选择排序
//时间复杂度 ：最坏O(n^2) 最好O(n^2) 平均O(n^2)
//空间复杂度：O(1)
//稳定性：稳定
void selectSort(int* array, int n){
int i,j;
for(i=0;i<n-1;i++){
int min=i;
for(j=i+1;j<n;j++){
if(array[j]<array[min])
min=j;
}
if(min!=i)
Swap(array,min,i);
}
}
void selectSort2(int* array, int n){//优化
int begin=0,end=n-1;
int i;
while(begin<end){
int min=begin,max=begin;
for(i=begin;i<=end;i++){
if(array[i]<array[min])
min=i;
if(array[i]>array[max])
max=i;
}
Swap(array,begin,min);
if(begin==max)
max=min;
Swap(array,end,max);
begin++;
end--;
}
}
//冒泡排序
//时间复杂度 ：最坏O(n^2) 最好O(n) 平均O(n^2)
//空间复杂度：O(1)
//稳定性：稳定
void bubbleSort(int* array, int n){
int i,j;
int flag=1;
for( i=0;i<n-1;i++){
for(j=0;j<n-1-i;j++){
if(array[j]>array[j+1])
Swap(array,j+1,j);
flag=0;
}
if(flag)
break;
}
}
//堆排序
//时间复杂度 ：O(nlgn)
//空间复杂度：O(1)
//稳定性：不稳定
void shiftDown(int* array, int n, int parent){
int child=2*parent+1;
while(child<n){
if(child+1<n&&array[child+1]>array[child])
child++;
if(array[child]>array[parent]){
Swap(array,child,parent);
parent=child;
child=2*parent+1;
}else
break;
}
}
void heapSort(int* array, int n){
int i;
for( i=(n-2)/2;i>=0;i--){
shiftDown(array,n,i);
}
int size=n;
for(i=0;i<n;i++){
Swap(array,0,size-1);
size--;
shiftDown(array,size,0);
}
}
//快速排序
//时间复杂度 ：最坏O(n^2)--优化后不会出现 最好O(nlgn) 平均O(nlgn)
//空间复杂度：O(lgn) 函数调用栈 最坏O(n)不会出现
//稳定性：不稳定
int getMid(int* array,int begin,int end){
int mid=begin+(end-begin)/2;
//begin,end,mid选中间值得位置
if(array[begin]<array[mid]){
if(array[mid]<array[end])
return mid;
else{//begin<mid end<=mid
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);
}