冒泡、归并、快速、桶、堆排序

最新推荐文章于 2023-02-08 21:13:26 发布

奔跑的梅花Lu

最新推荐文章于 2023-02-08 21:13:26 发布

阅读量494

点赞数 1

分类专栏：算法文章标签：排序

本文链接：https://blog.csdn.net/shengsikandan/article/details/51007117

版权

算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

小注：本文一开始的堆排序出现了错误，我没有直接改掉错误代码，而是把正确代码附在文末，看到的同学注意下，一定看到文末。希望童鞋们引以为戒。

一、冒泡排序。

每次和后面的元素比较，如果当前元素比后面的就交换。这样就会把最大的筛选到最后，经过n趟就可以排完。时间复杂度O（n^2）。对于元素数量很大的排序，时间非常慢。

void swap(int a[],int i,int j){    
	int t; 
	t = a[i];
	a[i] = a[j];
	a[j] = t;
}
int bubblesort(int a[],int n){         
	for(int i = 0; i < n; ++i){
		for(int j = 0; j < n-i-1; ++j){
			if(a[j] > a[j+1]) swap(a,j,j+1);
		}
	}
	return 0;
}

二、桶排序。

设置一个数组（就像一个桶），初始化为0，每次在下标为该元素的值的位置+1。很显然，尽管他的时间复杂度达到了O（m+n）（m是桶的个数，n是元素的个数），但是空间复杂度太大，对于较大的数，不能存储，而且对于稀疏元素，空间浪费极大！比如元素有5个 a[5] = {0,1000,1000000,100000000,1}，很显然，要开一个空间是10000000的数组，这是不现实的。所以桶排序只适用于数比较小的。

int bucketsort(int a[],int n){         
	int t[101] = {0};
	for(int i = 0; i < n; ++i)
		t[a[i]]++;
	int k = 0;
	for(int i = 0; i <= 100; ++i){
		while(t[i] != 0){
			a[k++] = i;
			t[i]--;
		}
	}
	return 0;
}

三、快速排序

设置2个游标，分别从头和尾开始找，从头找比a[first] 大的元素，从尾找比a[furst] 小的元素，然后交换，知道2个游标碰面停止，这时候这个位置一定是a[first]的正确的排序后的位置，然后把它换过去，这样一趟下来，就排好一个元素，并把序列分成2部分，再分别对2部分的排序。时间复杂度是O（n×logn）是一种很快的排序方法，适用于元素数量很大的排序

void swap(int a[],int i,int j){  //交换数组2个元素
	int t; 
	t = a[i];
	a[i] = a[j];
	a[j] = t;
}
int quicksort(int a[],int first,int last){   
	int i = first;
	int j = last;
	if(first > last) return 0;  //结束条件
	while(i != j){
		while(a[j] >= a[first] && i < j ) j--;    //找到从尾开始找比a[first]小的元素的位置
		while(a[i] <= a[first] && i < j) i++;     //找到从头开始比a[first]大的元素的位置
		if(i < j) swap(a,i,j);                   //如果i,j位置合法，交换他们的内容
	}
	swap(a,i,first);              //将开头的元素放到正确的位置
	quicksort(a,first,i-1);        //对前一部分排序
	quicksort(a,i+1,last);          //对后一部分排序
	return 1;
}

四、归并排序

归并排序是先将一个序列，分成2个一组的小序列，对他们排好序后，进行合并，知道合并成整个序列。归并排序利用分治思想，不断折半，时间复杂度是O（n×logn），速度很快

int merge(int a[],int first,int mid,int last,int b[]){  //合并2个子序列。将a数组的前半段和后半段进行合并，合并到数组b中，再把b的相应位置的内容返给a
	int i,j,m,n;
	j = mid + 1;
	n = mid;
	i = first;
	m = last;
	int k = 0;
	while(i <= n && j <= m){   //合并的过程，谁小先放谁
		if(a[i] < a[j])
			b[k++] = a[i++];
		else
			b[k++] = a[j++];
	}
	while(i <= n)
		b[k++] = a[i++];
	while(j <= m)
		b[k++] = a[j++];
	for( i = 0; i < k; ++i)
	    a[first+i] = b[i];
	return 0;
}
int mergesort(int a[],int first,int last,int b[]){   // //进行排序。分出子序列，分别排序
	if(first < last){
		int mid = (last + first) / 2;
		mergesort(a,first,mid,b);
		mergesort(a,mid+1,last,b);
		merge(a,first,mid,last,b);
	}
	return 0;
}

五、堆排序

堆排序，利用堆的性质，取出最小（大）的元素的复杂度是O（1）。而每次调整堆的复杂度是O（logn），所以每取一个元素，就要调整一次，要取n次，所以堆排序的时间复杂度是O（n×logn），而且堆排序很稳定

堆排序，重要的地方在于，构建堆与调整堆。

堆其实是一个完全二叉树，所以我们可以用数组来维护。也就是说，第i个节点的左右孩子分别是第2×i，2×i+1个节点

这里我用的是最小堆。

int shiftdown(int a[],int i,int n){             //向下调整
	if(2*i > n || 2*i+1 > n || i > n) return -1;   //超出边界退出
	if( a[i] > a[2*i] ){       //左孩子的值比它小，就交换他们，然后顺着向下调整
		swap(a,i,2*i);
		shiftdown(a,2*i,n);
	}
    if(a[i] > a[2*i+1]){             //右孩子的值比它小，就交换他们，然后顺着向下调整
		swap(a,i,2*i+1);
		shiftdown(a,2*i+1,n);
	}
	return 1;
}
int make_heap(int a[],int n){                  //创建一个堆。我们采取从下往上调整，但是叶节点是不用调整的，所以从倒数第二层调整就行
	for(int i = n/2; i >= 1; --i) shiftdown(a,i,n);
	return 1;
}
int heapsort(int a[],const int n){                //堆排序。每次取他的第一个元素，然后调整堆
    int t[n];
    int k = 0;
    int tn = n;
    make_heap(a,n);
    while(tn != 0){
    	t[k++] = a[1];
    	a[1] = a[tn];           //把最后一个元素放到第一个元素的位置，这样下面n的值就可以减掉1了
    	tn--;
    	shiftdown(a,1,tn);
    }
    for(int i = 0; i < n; ++i) a[i] = t[i];   //把它的结果返给a
    return 0;
}

六、完整代码：

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;
int aa[11] = {6,8,96,4,5,45,21,4,11,49};  //待排序序列
int merge(int a[],int first,int mid,int last,int b[]){  //¹归并。合并2个子序列
	int i,j,m,n;
	j = mid + 1;
	n = mid;
	i = first;
	m = last;
	int k = 0;
	while(i <= n && j <= m){
		if(a[i] < a[j])
			b[k++] = a[i++];
		else
			b[k++] = a[j++];
	}
	while(i <= n)
		b[k++] = a[i++];
	while(j <= m)
		b[k++] = a[j++];
	for( i = 0; i < k; ++i)
	    a[first+i] = b[i];
	return 0;
}
int mergesort(int a[],int first,int last,int b[]){   // 归并排序
	if(first < last){
		int mid = (last + first) / 2;
		mergesort(a,first,mid,b);
		mergesort(a,mid+1,last,b);
		merge(a,first,mid,last,b);
	}
	return 0;
}
void swap(int a[],int i,int j){     //交换元素
	int t; 
	t = a[i];
	a[i] = a[j];
	a[j] = t;
}
int quicksort(int a[],int first,int last){        // 快速排序
	int i = first;
	int j = last;
	if(first > last) return 0;
	while(i != j){
		while(a[j] >= a[first] && i < j ) j--;
		while(a[i] <= a[first] && i < j) i++;
		if(i < j) swap(a,i,j);
	}
	swap(a,i,first);
	quicksort(a,first,i-1);
	quicksort(a,i+1,last);
	return 1;
}
int bubblesort(int a[],int n){            //冒泡排序
	for(int i = 0; i < n; ++i){
		for(int j = 0; j < n-i-1; ++j){
			if(a[j] > a[j+1]) swap(a,j,j+1);
		}
	}
	return 0;
}
int bucketsort(int a[],int n){          //桶排序
	int t[101] = {0};
	for(int i = 0; i < n; ++i)
		t[a[i]]++;
	int k = 0;
	for(int i = 0; i <= 100; ++i){
		while(t[i] != 0){
			a[k++] = i;
			t[i]--;
		}
	}
	return 0;
}
int shiftdown(int a[],int i,int n){             //堆排序。向下调整
	if(2*i > n || 2*i+1 > n || i > n) return -1;
	if( a[i] > a[2*i] ){
		swap(a,i,2*i);
		shiftdown(a,2*i,n);
	}
    if(a[i] > a[2*i+1]){
		swap(a,i,2*i+1);
		shiftdown(a,2*i+1,n);
	}
	return 1;
}
int make_heap(int a[],int n){                  //´堆排序。构造堆
	for(int i = n/2; i >= 1; --i) shiftdown(a,i,n);
	return 1;
}
int heapsort(int a[],const int n){                //堆排序
    int t[n];
    int k = 0;
    int tn = n;
    make_heap(a,n);
    while(tn != 0){
    	t[k++] = a[1];
    	a[1] = a[tn];
    	tn--;
    	shiftdown(a,1,tn);
    }
    for(int i = 0; i < n; ++i) a[i] = t[i];
    return 0;
}
int main(){
	printf("排序前： ");
	for(int i = 0; i < 10; ++i) printf("%d ",aa[i]);
	printf("\n");
	//int bb[10];   //归并排序用的一个暂时数组
	//mergesort(aa,0,9,bb);
	//quicksort(aa,0,9);
	//bubblesort(aa,10);
	//bucketsort(aa,10);
	//aa[10] = aa[0];  //堆排序的下标是从1开始的。所以要把第0个元素放在第n个元素位置上
	//heapsort(aa,10);
	printf("排序后： ");
	for(int i = 0; i < 10; ++i) printf("%d ",aa[i]);
	return 0;
}

*********************************华丽的分割线******************************************************************

更正错误：

堆排序中shiftdown函数错了，在只有左孩子没有右孩子的情况下会出现错误。更正代码如下：

int shiftdown(int a[],int i,int n){             //堆排序。向下调整
	if(2*i <= n && 2*i+1 <= n){
		if( a[i] > a[2*i] ){
			swap(a,i,2*i);
			shiftdown(a,2*i,n);
		}
	    if(a[i] > a[2*i+1]){
			swap(a,i,2*i+1);
			shiftdown(a,2*i+1,n);
		}
	}
	else if(2*i <= n){
		if( a[i] > a[2*i] ){
			swap(a,i,2*i);
			shiftdown(a,2*i,n);
		}
	}
	
	return 1;
}

奔跑的梅花Lu

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
冒泡、归并、快速、桶、堆排序

一、冒泡排序。每次和后面的元素比较，如果当前元素比后面的就交换。这样就会把最大的筛选到最后，经过n趟就可以排完。时间复杂度O（n^2）。对于元素数量很大的排序，时间非常慢。void swap(int a[],int i,int j){ int t; t = a[i]; a[i] = a[j]; a[j] = t;}int bubbleso
复制链接

扫一扫