排序算法

排序算法

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.基数排序

时间复杂度：

空间复杂度

稳定性:

7.快速排序(很重要)

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

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

空间复杂度：O()

稳定性:不稳定

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.总结

标签：dk,int,void,稳定性,算法,排序,复杂度
来源： https://www.cnblogs.com/xjb714/p/16120239.html