排序算法

排序算法

1.冒泡排序

void Bubble_sort(ElementType A[],int n){
    for(i=0;i<n-1;i++){
        flag=false;
        for(j=n-1;j>=i;j--){
            if(A[j-1]>A[j]){
                swap(A[j-1],A[j]);
                flag=true;
            }
        }
        if(flag==false)return;//若本趟没有发生交换则表已经有序;
    }
}
//时间复杂度：最好O(n),最坏:O(n^2)  
//空间复杂度: O(1)
//稳定性:稳定

2.插入排序

void Insert_sort(ElementType A[],int n){
    int i,j,tmp;
	for(i=1;i<n;i++){
		tmp=A[i];
		j=i-1;
		while(j>=0&&A[j]>tmp){
			A[j+1]=A[j];
			j--;
		}
		A[j+1]=tmp;
	}
}
//时间复杂度:最好O(n)，最坏O(n^2)
//空间复杂度：O(1)
//稳定性：稳定

3.希尔排序

void ShellSort(ElementType A[],int n){
    for(dk=n/2;dk>=1;dk/=2){
        for(i=dk+1;i<=n;++i){
            if(A[i]<A[i-dk]){
                A[0]=A[i];
                for(j=i-dk;j>0&&A[0]<A[j];j-=dk)
                    A[j+dk]=A[j];
            }
        }
    }
}
//时间复杂度：平均：O(n^1.3) 最坏:O(n^2)
//空间复杂度:O(1)
//稳定性:不稳定

4.堆排序

平均比较次数:2NlogN-O(NloglogN)

时间复杂度:O(NlogN)

空间复杂度:O(1)

稳定性：不稳定

5.2路归并排序

空间复杂度：O(N)

时间复杂度:O(NlogN)

稳定性：稳定

6.基数排序

时间复杂度：O(d(n+r))

空间复杂度: O(1)

稳定性:稳定

7.快速排序(很重要)

实际应用中最好的算法，平均性能最好

时间复杂度：O(NlogN) 最坏：O(N^2)

空间复杂度：O(logN)

稳定性:不稳定!

void qsort(int *arr,int begin,int end){
    if(begin<end){
        int temp=arr[begin],i=begin,j=end;
        while(i<j){
            while(i<j&&arr[j]>=temp)--j;
            arr[i]=arr[j];
            while(i<j&&arr[i]<=temp)++i;
            arr[j]=arr[i];
        }
        arr[i]=temp;//将第一个数放在最终位置
        qsort(arr,begin,i-1);
        qsort(arr,i+1,end);
    }
}

8.总结

排序方法	平均时间复杂度	最坏时间复杂度	额外空间复杂度	稳定性
简单选择排序	O($n^2$)	O($n^2$)	O(1)	不稳定
冒泡排序	O($n^2$)	O($n^2$)	O(1)	稳定
直接插入排序	O($n^2$)	O($n^2$)	O(1)	稳定
希尔排序	O($n^d$)	O($n^2$)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(1)	不稳定
快速排序	O(nlogn)	O($n^2$)	O(logn)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(n)	稳定
基数排序	O(P(N+B))	O(P(N+B))	O(N+B)	稳定