python算法之冒泡排序


排序算法(Sorting algorithm)

所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。排序算法,就是如何使得记录按照要求排列的方法。

稳定性

稳定的算法在排序的过程中不会改变元素彼此的位置的相对次序,会让原本有相对键值的记录维持相对次序。
例设以下的几个单词,以第一个字母来排序
bubble
count
unite
celerity
select

在这个情况下,有可能产生两种不同的结果,一种是让相等键值的记录维持相同的次序,而另一个则没有

bubble, celerity, count, select, unite (维持次序)
bubble, count, celerity, select, unite (次序被改变)

不稳定的排序算法经常会改变这个次序,这是我们不愿意看到的。稳定算法就从来不会如此。对于不稳定的排序算法,只要举出一个实例,即可说明它的不稳定性;而对于稳定的排序算法,必须对算法进行分析从而得到稳定的特性。需要注意的是,排序算法是否为稳定的是由具体算法决定的,不稳定的算法在某种条件下可以特别的实现为稳定,而稳定的算法在某种条件下也可以被特别的实现为不稳定。

冒泡排序

冒泡排序(Bubble Sort)是一种非常简单的排序算法。它重复遍历要排序的元素列,依次比较两个相邻的元素,如果他们的顺序错误就把他们交换过来。遍历元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同水中的泡泡最终会上浮出水面一样,故名“冒泡排序”。

冒泡排序的运作方式如下:

  • 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
  • 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
  • 针对所有的元素重复以上的步骤,除了最后一个。
  • 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

冒泡排序的分析

要排序的数组

list =  [16,9,53,24,71,33,20,19]

第一轮交换过程

在这里插入图片描述
我们就需要进行n-1次的冒泡过程,每次对应的比较次数如下
| 1 | n-1 |
| 2 | n-2 |
| 3 | n-3 |

#第一轮
n = len(list)
for i in range(0,n-1):#这个i就是游标走的地方
		#判断如果第一个数大于第二个数
		if list[i] > list[i+1]:
			#交换位置
			list[i],list[i+1] = list[i+1],list[i]
	

第二轮交换
第一次比较,9比16小, 不交换位置 [9,16,24,53,33,20,19,71]
第二次比较,16比24小,不交换位置 [9,16,24,53,33,20,19,71]
第三次比较,24比53小,不交换位置 [9,16,24,53,33,20,19,71]
第四次比较,53比33大,交换位置 [9,16,24,33,53,20,19,71]
第五次比较,53比20大,交换位置 [9,16,24,33,20,53,19,71]
第六次比较,53比19大,交换位置 [9,16,24,33,20,19,53,71]
在这里插入图片描述

#第二轮
n = len(list)
for i in range(0,n-1-1):#这个i就是游标走的地方
		#判断如果第一个数大于第二个数
		if list[i] > list[i+1]:
			#交换位置
			list[i],list[i+1] = list[i+1],list[i]

第三轮交换
第一次比较,9比16小, 不交换位置 [9,16,24,33,20,19,53,71]
第二次比较,16比24小,不交换位置 [9,16,24,33,20,19,53,71]
第三次比较,24比33小,不交换位置 [9,16,24,33,20,19,53,71]
第四次比较,33比20大,交换位置 [9,16,24,20,33,19,53,71]
第五次比较,33比19大,交换位置 [9,16,24,20,19,33,53,71]
在这里插入图片描述

#第三轮
n = len(list)
for i in range(0,n-1-2):#这个i就是游标走的地方
		#判断如果第一个数大于第二个数
		if list[i] > list[i+1]:
			#交换位置
			list[i],list[i+1] = list[i+1],list[i]

第四轮交换
第一次比较,9比16小, 不交换位置 [9,16,24,20,19,33,53,71]
第二次比较,16比24小,不交换位置 [9,16,24,20,19,33,53,71]
第三次比较,24比20大,交换位置 [9,16,20,24,19,33,53,71]
第四次比较,24比19大,交换位置 [9,16,20,19,24,33,53,71]
在这里插入图片描述

#第四轮
n = len(list)
for i in range(0,n-1-3):#这个i就是游标走的地方
		#判断如果第一个数大于第二个数
		if list[i] > list[i+1]:
			#交换位置
			list[i],list[i+1] = list[i+1],list[i]

第五轮交换
第一次比较,9比16小, 不交换位置 [9,16,20,19,24,33,53,71]
第二次比较,16比20小,不交换位置 [9,16,20,19,24,33,53,71]
第三次比较,20比19大,交换位置 [9,16,19,20,24,33,53,71]
在这里插入图片描述

#第五轮
n = len(list)
for i in range(0,n-1-4):#这个i就是游标走的地方
		#判断如果第一个数大于第二个数
		if list[i] > list[i+1]:
			#交换位置
			list[i],list[i+1] = list[i+1],list[i]

经过五轮交换,已经是有序的了

代码如下(示例):

def bubble_sort(list):
	n = len(list)
	#交换次数
	record = 0
	#这里遍历的是走了多少轮
	for j in range(n-1):
		'''从上面我们发现我们每轮都会少遍历一次
		所以我们这里减去j就刚好达到效果'''
		for i in range(0,n-1-j):#这个i就是游标走的地方
			#判断如果第一个数大于第二个数
			if list[i] > list[i+1]:
				#交换位置
				list[i],list[i+1] = list[i+1],list[i]
				#每次交换次数加1
				record += 1
		#交换次数为0表示整个遍历下来没有交换
		if record == 0return
l =  [16,9,53,24,71,33,20,19]
bubble_sort(l)
print(l)

综上所述:

  • 如果我们的数据正序,只需要走一趟即可完成排序。冒泡排序最好的时间复杂度为O(n)。
  • 冒泡排序总的平均时间复杂度为:O(n2) ,时间复杂度和数据状况无关。

稳定性:稳定

编辑过程中如有疏漏和错误的地方还请各位大佬指正。期待相互关注,一起学习

相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页