6.1 冒泡排序

一. 排序算法概述:

  (1)排序与搜索:

    排序算法(英语:Sorting algorithm)是一种能将一串数据依照特定顺序进行排列的一种算法。

  (2)排序算法的稳定性:

    稳定性:稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的,当有两个相等键值的纪录R和S,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前。

    当相等的元素是无法分辨的,比如像是整数,稳定性并不是一个问题。然而,假设以下的数对将要以他们的第一个数字来排序。

    

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

    

    不稳定排序算法可能会在相等的键值中改变纪录的相对次序,但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地实现为稳定。作这件事情的一个方式是人工扩充键值的比较,如此在其他方面相同键值的两个对象间之比较,(比如上面的比较中加入第二个标准:第二个键值的大小)就会被决定使用在原先数据次序中的条目,当作一个同分决赛。然而,要记住这种次序通常牵涉到额外的空间负担。

二. 冒泡排序:

  (1)冒泡排序:

    冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

    冒泡排序算法的运作如下:   

      比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个。

      对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

      针对所有的元素重复以上的步骤,除了最后一个。

      持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

  (2)冒泡排序的分析:

    交换过程图示(第一次):

    

    那么我们需要进行n-1次冒泡过程,每次对应的比较次数如下图所示:

    

  (3)代码实现:

 1 # 方法一:
 2 def bubble_sort1(alist):
 3     """冒泡排序"""
 4     n = len(alist)
 5     # 外层循环,表示班长走多少遍
 6     for j in range(n-1):              # j的范围:[0,1,2,3, ... ,n-2]
 7         # 内层循环,表示班长从头走到尾
 8         for i in range(0, n-1-j):     # i的范围是 0 --> n-2  [0,n-1)
 9             if alist[i] > alist[i+1]:
10                 alist[i], alist[i+1] = alist[i+1], alist[i]     # 交换alist[i]与alist[i+1]的位置
11 
12 # 方法二:
13 def bubble_sort2(alist):
14     for j in range(len(alist)-1, 0, -1):    # j的范围:[n-1,n-2,n-3, ... ,1]
15         # j表示每次遍历需要比较的次数,是逐渐减小的
16         for i in range(j):
17             if alist[i] > alist[i+1]:
18                 alist[i], alist[i+1] = alist[i+1], alist[i]
19 
20 # 方法三:改进版(针对于,如果原本序列就有序的话以上方法还是需要一一比较)
21 def bubble_sort3(alist):
22     """冒泡排序"""
23     n = len(alist)
24     # 外层循环,表示班长走多少遍
25     for j in range(n-1):              # j的范围:[0,1,2,3, ... ,n-2]
26         count = 0   #代表从来没有交换
27         # 内层循环,表示班长从头走到尾
28         for i in range(0, n-1-j):     # i的范围是 0 --> n-2  [0,n-1)
29             if alist[i] > alist[i+1]:
30                 alist[i], alist[i+1] = alist[i+1], alist[i]     # 交换alist[i]与alist[i+1]的位置
31                 count += 1
32         if 0 == count:
33             return
34 
35 if __name__ == "__main__":
36     li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
37     print("方法一:")
38     print(li)
39     bubble_sort1(li)
40     print(li)
41     print("-"*50)
42 
43     li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
44     print("方法二:")
45     print(li)
46     bubble_sort1(li)
47     print(li)
48     print("-"*50)
49 
50     li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
51     print("方法三:")
52     print(li)
53     bubble_sort1(li)
54     print(li)

  (4)运行结果:

      

  (5)时间复杂度:

      最优时间复杂度:O(n) (表示遍历一次发现没有任何可以交换的元素,排序结束。)

      最坏时间复杂度:O(n2)

      稳定性:稳定

  (6)冒泡排序的演示:

      效果:

      

posted @ 2018-07-04 17:16  博观&约取  阅读(721)  评论(0编辑  收藏  举报