算法学习之排序算法:冒泡排序

冒泡排序:不同于插入排序,冒泡排序主要通过“交换”来完成。

基本思想:

1、将第一个记录的关键字和第二个记录的关键字进行比较,若为逆序(Record[1].key > Record[2].key),则将两个记       录交换之,然后比较第二个记录和第三个记录的关键字。

2、依次类推,直至第n-1个记录和第n个记录的关键字被安置到最后一个记录的位置上。完成第一趟冒泡排序。结果         使得关键字最大的记录被安置到最后一个记录的位置上。

3、进行第二趟冒泡排序,对前n-1个记录进行同样的操作,其结果是使关键字次大的记录被安置到第n-1个记录的位         置上。第i趟冒泡排序是从Record[1]到Record[n-i+1]依次比较相邻两个记录的关键字,并在“逆序”时交换相邻记            录,其结果是这n-i+1个记录中关键字最大的记录被交换到第n-i+1的位置上。

4、整个排序过程需要进行k(1<=k<n)趟冒泡排序,判别冒泡排序结束的条件是“在一趟排序过程中没有进行过交换记        录的操作”。

下面以8个记录为例进行分析如下:

初始关键字:49   38   65   97   76   13   27   49

第一趟冒泡:49   38   65   97   76   13   27   49//比较第一个跟第二个记录的关键字,逆序,交换

38   49   65   97   76   13   27   49

38  
49   65   97   76   13   27   49//比较第二个跟第三个记录的关键字,逆序,交换

38   65   49   97   76   13   27   49

38   65   49   97   76   13   27   49//比较第三个跟第四个记录的关键字,正序,不变

38   65   49   97   76   13   27   49

38   65   49  97   76
  13   27   49//比较第四个跟第五个记录的关键字,逆序,交换

38   65   49   76   97   13   27   49

38   65   49   76  97   13   27   49//比较第五个跟第六个记录的关键字,逆序,交换

38   65   49   76   13   97   27   49

38   65   49   76   13  97   27   49//比较第六个跟第七个记录的关键字,逆序,交换

38   65   49   76   13   27   97   49

38   65   49   76   13   27  97   49//比较第七个跟第八个记录的关键字,逆序,交换

38   65   49   76   13   27   49   97

第一趟冒泡排序结束,最大值97被安置到最后一个记录上。依次后面的冒泡排序:

38   65   49   76   13   27   49
  97

第二趟冒泡排序结束:38   65   49   13
  27   49   76   97

第三趟冒泡排序结束:38   49   13   27   49  65  
76   97

第四趟冒泡排序结束:38   13   27   49  49  
65   76   97

第五趟冒泡排序结束:38   13   27  49   49   65
  76   97

第六趟冒泡排序结束:13   27  38   49   49
  65   76   97

第七趟冒泡排序,没有记录进行交换,因此冒泡排序结束,最后的冒泡排序顺序为:

13   27   38   49
  49   65   76   97

示例代码(C语言实现):

/*********************************************************************
 Author:李冰 date:2014-9-6
 Email:[email protected]
 @array: the pointer to the records
 @num:the length of the records
*********************************************************************/
void bubblesort(int array[], int num)
{
	if(array == NULL || num < 0)
		return;

	int i, j, tmp;

	for(i = 0; i < num; i++)
		for(j = 1; j < num - i; j++)
			if(array[j-1] > array[j]){
				tmp = array[j-1];
				array[j-1] = array[j];
				array[j] = tmp;
			}
}

上面的代码时严格按照冒泡排序进行的,但未利用冒泡排序是否结束的判断。下面对其进行优化,设置一个标志,如果这一趟发生了交换,则为true,否则为false。明显如果有一趟没有发生交换,说明排序已经完成。

示例代码2(C语言描述):

/*********************************************************************
 Author:李冰 date:2014-9-6
 Email:[email protected]
 @array: the pointer to the records
 @num:the length of the records
*********************************************************************/
void bubblesort(int array[], int num)
{
	int j, tmp;
	bool flag;

	flag = true; //冒泡排序结束判断标志
	while(flag){
		flag = false;
		for(j = 1; j < num; j++)
			if(array[j-1] > array[j]){
				tmp = array[j-1];
				array[j-1] = array[j];
				array[j] = tmp;
				flag = true;
			}
		num--;
	}
}

总结:

1、冒泡排序总的时间复杂度为O(n^2)。

2、可以设置冒泡排序完成判断标志flag,如果某一趟冒泡排序没有进行记录交换,则冒泡排序完成。

3、注意示例代码中的边界判断。

参考文献:

1、《数据结构(C语言版)》严蔚敏 吴伟东 编著

2、http://blog.csdn.net/morewindows/article/details/6668714

3、http://blog.csdn.net/to_be_it_1/article/details/37866391

时间: 2024-10-04 11:54:00

算法学习之排序算法:冒泡排序的相关文章

算法学习之排序算法:插入排序(直接插入排序、折半插入排序、2-路插入排序)

引言: 插入排序作为最简单易于理解的排序算法,基本实现比较简单.本文详细介绍直接插入排序,并给出实现,简单的介绍折半插入排序,并给出2-路插入排序和表插入排序两种插入排序,但并未给出具体实现. 一.直接插入排序 直接插入排序的基本操作是将一个记录插入到已排好序的有序表中,从而得到一个新的.记录数增1的有序表. 算法描述: 步骤1.将待排序的一组记录中的第1个记录拿出来作为一组有序的记录(当然此时该组记录仅有1个记录). 步骤2.依次将待排序的一组记录中的记录拿出来插入到前面已排好序的记录中. 步

算法学习之排序算法(五)(高速排序)

1.算法思想 设要排序的数组是A[0]--A[N-1],首先随意选取一个数据(通常选用数组的第一个数)作为重要数据,然后将全部比它小的数都放到它前面.全部比它大的数都放到它后面.这个过程称为一趟高速排序.值得注意的是,高速排序不是一种稳定的排序算法.也就是说,多个同样的值的相对位置或许会在算法结束时产生变动. 一趟高速排序的算法是: 1)设置两个变量i.j.排序開始的时候:i=0.j=N-1. 2)以第一个数组元素作为重要数据,赋值给key.即key=A[0]. 3)从j開始向前搜索,即由后開始

算法学习之排序算法(三)(选择排序法)

1.引言 选择排序工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完. 选择排序是不稳定的排序方法.选择排序是和冒泡排序差不多的一种排序.和冒泡排序交换相连数据不一样的是,选择排序只有在确定了最小的数据之后,才会发生交换.怎么交换呢?我们可以以下面一组数据作为测试: 2, 1, 5, 4, 9 第一次排序:1, 2, 5, 4, 9 第二次排序: 1, 2, 5, 4, 9 第三次排序: 1, 2, 4, 5, 9 第四次排序:

算法学习之排序算法:快速排序

快速排序:快速排序是对冒泡排序的一种改进.它的基本思想是,通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序. 一趟快速排序的具体做法: 1.附设两个指针low和high,它们的初值分别为low和high,设枢轴记录的关键字为pivotkey. 2.首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换. 3.从low所指位置起向后搜索,找到第一个关键字大于piv

[算法学习笔记]排序算法——堆排序

堆排序 堆排序(heapsort)也是一种相对高效的排序方法,堆排序的时间复杂度为O(n lgn),同时堆排序使用了一种名为堆的数据结构进行管理. 二叉堆 二叉堆是一种特殊的堆,二叉堆是完全二叉树或者是近似完全二叉树.二叉堆满足堆特性:父节点的键值总是保持固定的序关系于任何一个子节点的键值,且每个节点的左子树和右子树都是一个二叉堆. 如上图显示,(a)是一个二叉堆(最大堆), (b)是这个二叉堆在数组中的存储形式. 通过给个一个节点的下标i, 很容易计算出其父节点,左右子节点的的下标,为了方便,

算法学习之排序算法:堆排序

要了解堆排序,首先要了解堆的概念,因为本文主要研究堆排序的算法,此处对数据结构堆只是给出概念:n个元素的序列{k1,k2,...kn},当且仅当满足如下关系时,称之为堆. k[i] <= k[2i]且k[i] <= k[2i+1] (或 k[i] >= k[2i]且k[i] >= k[2i+1]) 比如:序列96.83.27.38.11.09(或12.36.24.85.47.30.53.91)都是堆. 如果将堆对应的一维数组看成是一个二叉树,则堆的含义表明:完全二叉树中所有非终端结

算法学习之排序算法:归并排序

"归并"的含义是将两个或两个以上的有序表组合成一个新的有序表.无论是顺序存储还是链表存储结构,都可在O(m+n)的时间量级上实现. 归并排序又是一类不同的排序方法.假设初始序列含有n个记录,则可看成是n个有序的子序列,每个子序列的长度为1,然后两两归并,得到n/2个为2或1的有序子序列:再两两归并,....... ,如此重复,直至得到一个长度为n的有序序列为止. 初始关键字:[49]   [38]   [65]   [97]   [76]   [13]   [27] A       A

算法学习之排序算法:选择排序

选择排序:每一趟在n-i+1(i=1,2,...,n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录. 一.简单选择排序 一趟选择排序操作: 通过n-i次关键字间的比较,从n-i+1个记录中选出关键字最小的记录,并和第i(1<=i<=n)个记录交换之. 对L[1...n]中记录进行简单选择排序的算法为:令i从1至n-1,进行n-1趟选择操作.简单选择排序过程中,所需进行记录移动的操作次数较少,然而,无论记录的初始排列如何,所需关键字间的比较次数相同.因此,总的时间复杂度为O(n^2)

算法学习之排序算法(四)(希尔排序)

1.算法思想 先将整个待排元素序列分割成若干个子序列(由相隔某个"增量"的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序.因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的,因此希尔排序在时间效率上比前两种方法有较大提高. 希尔(Shell)排序又称为缩小增量排序,它是一种插入排序.它是直接插入排序算法的一种威力加强版. 希尔排序的基本思想是 把记录按步长 gap 分组,对每组