Python3&数据结构之冒泡排序

冒泡排序顾名思义，这个算法的过程可以理解为水泡从水底冒出来这种现象，且越到上面的气泡越大。

一、基本步骤：

1.冒泡排序要排序n个数，由于每遍历一趟只排好一个数字，则需要遍历n-1趟，所以最外层循环是要循环n-1次

 

2.每次趟遍历中需要比较每归位的数字，则要在n-1次比较中减去已排好的i位数字，则第二层循环要遍历是n-1-i次

注：1中每次循环都会吐出最大（最小）气泡（也就是数字），2中每次循环都是比较两个位置上数字的大小。

二、举例说明：

比如给出一组数字：9, 5, 8, 76, 1

【0】第一次外循环：

[4]    1        1        1        1        76

[3]    76      76      76      76      1

[2]    8        8        9        9        9

[1]    5        9        8        8        8                    

[0]    9        5        5        5        5     

注：内循环比较顺序：[0][1]，[1][2]，[2][3]，[3][4]上的数字相比较 ，红色数字表示内较大的数字，蓝色数字表示外循环吐出的数字。

因为第一列是输入数据，所以前4列是比较过程，后4列是输出结果。

 

【1】第二次外循环：

 

[4]    76      76      76      76       

[3]    1        1        1        9      

[2]    9        9        9        1        

[1]    8        8        8        8                          

[0]    5        5        5        5        

注：内循环比较顺序：[0][1]，[1][2]，[2][3]

 

【2】第三次外循环：

 

[4]    76      76      76             

[3]    9        9        9             

[2]    1        1        8               

[1]    8        8        1                                 

[0]    5        5        5           

注：内循环比较顺序：[0][1]，[1][2]

 

【3】第四次外循环：

[4]    76      76               

[3]    9        9                  

[2]    8        8                      

[1]    1        5                                        

[0]    5        1                  

注：内循环比较顺序：[0][1]

可以看出来这里一共执行了10次循环

所以冒泡排序的循环的次数为：n（n-1）/2   ，n是数字的个数：len(datas)

所以其时间复杂度是：O(n²)

 

三、python3代码实现：

3.1实现冒泡思想

        for i in range(self.datas_len-1):
            for j in range(self.datas_len-1-i):
                if (self.datas[j]<self.datas[j+1]): #j<j+1:从大到小排列，j>j+1:从小到大排列
                    self.datas[j],self.datas[j+1] = self.datas[j+1],self.datas[j]

 

3.2完整例子代码

class BubbleSort(object):

    def __init__(self,datas):
        self.datas = datas
        self.datas_len = len(datas)

    def _sort(self):
        for i in range(self.datas_len-1):
            for j in range(self.datas_len-1-i):
                if (self.datas[j]<self.datas[j+1]): #j<j+1:从大到小排列，j>j+1:从小到大排列
                    self.datas[j],self.datas[j+1] = self.datas[j+1],self.datas[j]

    def show(self):
        print("Result is:")
        for i in self.datas:
            print(i,end=" ")

def main():
    try:
        #datas = input("Please input some number:") #自己输入
        datas = "9 5 8 76 1"   #输入例子
        datas = datas.split()
        datas = list(map(lambda i:int(i),datas))
        #把list里的str转成int，['9', '5', '8', '76', '1']转换[9, 5, 8, 76, 1]
        #或者使用 datas = [int(datas[i]) for i in range(len(datas))]
    except Exception as e:
        raise e

    bls = BubbleSort(datas)
    bls._sort()
    bls.show()

if __name__ == '__main__':
    main()

'''
Result is:
76 9 8 5 1 
'''

 

看到个更简单的

    for i in range(len(array)-1):
        for j in range(i,len(array)):
            if array[i]>array[j]:
                array[i],array[j] = array[j],array[i]

完整的测试代码

def bubble_sort(array):
    count = 0
    for i in range(len(array)-1):
        print("第%d次内循环:"%(i+1))
        for j in range(i,len(array)):
            if array[i]>array[j]:
                array[i],array[j] = array[j],array[i]
                count += 1
                print(array)
    print("count is %d"%count)
    print("Result is:")
    return array
print(bubble_sort([9,5,8,76,1]))
'''
第1次内循环:
[5, 9, 8, 76, 1]
[1, 9, 8, 76, 5]
第2次内循环:
[1, 8, 9, 76, 5]
[1, 5, 9, 76, 8]
第3次内循环:
[1, 5, 8, 76, 9]
第4次内循环:
[1, 5, 8, 9, 76]
count is 6
Result is:
[1, 5, 8, 9, 76]
'''

外循环次数没变，内循环次数由10减少到6。结论：通过减少内循环次数来缩短时间。