冒泡排序python代码

Posted 2023-05-10

参考技术A .example-btncolor:#fff;background-color:#5cb85c;border-color:#4cae4c.example-btn:hovercolor:#fff;background-color:#47a447;border-color:#398439.example-btn:activebackground-image:nonediv.examplewidth:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)div.example_codeline-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;word-break:break-all;word-wrap:break-worddiv.example_resultbackground-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%div.codewidth:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0div.code divfont-size:110%div.code div,div.code p,div.example_code pfont-family:"courier new"premargin:15px auto;font:12px/20px Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px 排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。以下是冒泡排序算法：

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

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来
说并没有什么太大作用。 1. 算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。

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

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

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
2. 动图演示

3. 什么时候最快
当输入的数据已经是正序时（都已经是正序了，我还要你冒泡排序有何用啊）。
4. 什么时候最慢
当输入的数据是反序时（写一个 for 循环反序输出数据不就行了，干嘛要用你冒泡排序呢，我是闲的吗）。 5. javascript 代码实现 实例 function bubbleSort ( arr )
    var len = arr. length ;
    for ( var i = 0 ; i arr [ j+ 1 ] :
                arr [ j ] , arr [ j + 1 ] = arr [ j + 1 ] , arr [ j ]
    return arr
7. Go 代码实现 实例 func bubbleSort ( arr [] int ) [] int
        length := len ( arr )
        for i := 0 ; i < length ; i ++
                for j := 0 ; j < length - 1 - i ; j ++
                        if arr [ j ] > arr [ j + 1 ]
                                arr [ j ], arr [ j + 1 ] = arr [ j + 1 ], arr [ j ]
                       
               
       
        return arr

8. Java 代码实现 实例 public class BubbleSort implements IArraySort

    @Override
    public int [ ] sort ( int [ ] sourceArray ) throws Exception
        // 对 arr 进行拷贝，不改变参数内容
        int [ ] arr = Arrays . copyOf ( sourceArray, sourceArray. length ) ;

        for ( int i = 1 ; i

Python冒泡排序

Python代码：

"""
冒泡排序（5）

双向冒泡，冒泡排序的一种变形。
在未排序的数中，每轮找出最小和最大的数分别放到首尾。

本例中：
第1轮：先将9放到正确位置，再将0放到正确位置；
第2轮：先将8放到正确位置，再将1放到正确位置；
第3轮：先将7放到正确位置，再将2放到正确位置；
第4轮：先将6放到正确位置，再将3放到正确位置；
第5轮：先将5放到正确位置，再将4放到正确位置；

"""

lst = [3, 6, 9, 1, 8, 7, 2, 5, 4, 0]
print("排序前: %s\r\n" %lst)

# 轮
for i in range(int(len(lst)/2)):
    print("第%s轮" % (i+1))
    # 次
    for m in range(i,len(lst)-i-1):
        # 如果前大后小，则交换位置
        if lst[m] > lst[m+1]:
            lst[m],lst[m+1] = lst[m+1],lst[m]
            print("    右向冒泡第%s次 [%s]:%s,[%s]:%s比较 互换 %s" % (m-i+1,m,lst[m+1],m+1,lst[m],lst))
        else:
            print("    右向冒泡第%s次 [%s]:%s,[%s]:%s比较 不变 %s" % (m-i+1,m,lst[m],m+1,lst[m+1],lst))
    print("\r\n")
    # 次
    for n in range(len(lst)-i-2,i,-1):
        # 如果前大后小，则交换位置
        if lst[n-1] > lst[n]:
            lst[n-1],lst[n] = lst[n],lst[n-1]
            print("    左向冒泡第%s次 [%s]:%s,[%s]:%s比较 互换 %s" % (9-n-i,n-1,lst[n],n,lst[n-1],lst))
        else:
            print("    左向冒泡第%s次 [%s]:%s,[%s]:%s比较 不变 %s" % (9-n-i,n-1,lst[n-1],n,lst[n],lst))

print("\r\n排序后:  %s" % lst)

输出结果：

E:\python\algorithm>python3 bubbleSort5.py
排序前: [3, 6, 9, 1, 8, 7, 2, 5, 4, 0]

第1轮
    右向冒泡第1次 [0]:3,[1]:6比较 不变 [3, 6, 9, 1, 8, 7, 2, 5, 4, 0]
    右向冒泡第2次 [1]:6,[2]:9比较 不变 [3, 6, 9, 1, 8, 7, 2, 5, 4, 0]
    右向冒泡第3次 [2]:9,[3]:1比较 互换 [3, 6, 1, 9, 8, 7, 2, 5, 4, 0]
    右向冒泡第4次 [3]:9,[4]:8比较 互换 [3, 6, 1, 8, 9, 7, 2, 5, 4, 0]
    右向冒泡第5次 [4]:9,[5]:7比较 互换 [3, 6, 1, 8, 7, 9, 2, 5, 4, 0]
    右向冒泡第6次 [5]:9,[6]:2比较 互换 [3, 6, 1, 8, 7, 2, 9, 5, 4, 0]
    右向冒泡第7次 [6]:9,[7]:5比较 互换 [3, 6, 1, 8, 7, 2, 5, 9, 4, 0]
    右向冒泡第8次 [7]:9,[8]:4比较 互换 [3, 6, 1, 8, 7, 2, 5, 4, 9, 0]
    右向冒泡第9次 [8]:9,[9]:0比较 互换 [3, 6, 1, 8, 7, 2, 5, 4, 0, 9]


    左向冒泡第1次 [7]:4,[8]:0比较 互换 [3, 6, 1, 8, 7, 2, 5, 0, 4, 9]
    左向冒泡第2次 [6]:5,[7]:0比较 互换 [3, 6, 1, 8, 7, 2, 0, 5, 4, 9]
    左向冒泡第3次 [5]:2,[6]:0比较 互换 [3, 6, 1, 8, 7, 0, 2, 5, 4, 9]
    左向冒泡第4次 [4]:7,[5]:0比较 互换 [3, 6, 1, 8, 0, 7, 2, 5, 4, 9]
    左向冒泡第5次 [3]:8,[4]:0比较 互换 [3, 6, 1, 0, 8, 7, 2, 5, 4, 9]
    左向冒泡第6次 [2]:1,[3]:0比较 互换 [3, 6, 0, 1, 8, 7, 2, 5, 4, 9]
    左向冒泡第7次 [1]:6,[2]:0比较 互换 [3, 0, 6, 1, 8, 7, 2, 5, 4, 9]
    左向冒泡第8次 [0]:3,[1]:0比较 互换 [0, 3, 6, 1, 8, 7, 2, 5, 4, 9]
第2轮
    右向冒泡第1次 [1]:3,[2]:6比较 不变 [0, 3, 6, 1, 8, 7, 2, 5, 4, 9]
    右向冒泡第2次 [2]:6,[3]:1比较 互换 [0, 3, 1, 6, 8, 7, 2, 5, 4, 9]
    右向冒泡第3次 [3]:6,[4]:8比较 不变 [0, 3, 1, 6, 8, 7, 2, 5, 4, 9]
    右向冒泡第4次 [4]:8,[5]:7比较 互换 [0, 3, 1, 6, 7, 8, 2, 5, 4, 9]
    右向冒泡第5次 [5]:8,[6]:2比较 互换 [0, 3, 1, 6, 7, 2, 8, 5, 4, 9]
    右向冒泡第6次 [6]:8,[7]:5比较 互换 [0, 3, 1, 6, 7, 2, 5, 8, 4, 9]
    右向冒泡第7次 [7]:8,[8]:4比较 互换 [0, 3, 1, 6, 7, 2, 5, 4, 8, 9]


    左向冒泡第1次 [6]:5,[7]:4比较 互换 [0, 3, 1, 6, 7, 2, 4, 5, 8, 9]
    左向冒泡第2次 [5]:2,[6]:4比较 不变 [0, 3, 1, 6, 7, 2, 4, 5, 8, 9]
    左向冒泡第3次 [4]:7,[5]:2比较 互换 [0, 3, 1, 6, 2, 7, 4, 5, 8, 9]
    左向冒泡第4次 [3]:6,[4]:2比较 互换 [0, 3, 1, 2, 6, 7, 4, 5, 8, 9]
    左向冒泡第5次 [2]:1,[3]:2比较 不变 [0, 3, 1, 2, 6, 7, 4, 5, 8, 9]
    左向冒泡第6次 [1]:3,[2]:1比较 互换 [0, 1, 3, 2, 6, 7, 4, 5, 8, 9]
第3轮
    右向冒泡第1次 [2]:3,[3]:2比较 互换 [0, 1, 2, 3, 6, 7, 4, 5, 8, 9]
    右向冒泡第2次 [3]:3,[4]:6比较 不变 [0, 1, 2, 3, 6, 7, 4, 5, 8, 9]
    右向冒泡第3次 [4]:6,[5]:7比较 不变 [0, 1, 2, 3, 6, 7, 4, 5, 8, 9]
    右向冒泡第4次 [5]:7,[6]:4比较 互换 [0, 1, 2, 3, 6, 4, 7, 5, 8, 9]
    右向冒泡第5次 [6]:7,[7]:5比较 互换 [0, 1, 2, 3, 6, 4, 5, 7, 8, 9]


    左向冒泡第1次 [5]:4,[6]:5比较 不变 [0, 1, 2, 3, 6, 4, 5, 7, 8, 9]
    左向冒泡第2次 [4]:6,[5]:4比较 互换 [0, 1, 2, 3, 4, 6, 5, 7, 8, 9]
    左向冒泡第3次 [3]:3,[4]:4比较 不变 [0, 1, 2, 3, 4, 6, 5, 7, 8, 9]
    左向冒泡第4次 [2]:2,[3]:3比较 不变 [0, 1, 2, 3, 4, 6, 5, 7, 8, 9]
第4轮
    右向冒泡第1次 [3]:3,[4]:4比较 不变 [0, 1, 2, 3, 4, 6, 5, 7, 8, 9]
    右向冒泡第2次 [4]:4,[5]:6比较 不变 [0, 1, 2, 3, 4, 6, 5, 7, 8, 9]
    右向冒泡第3次 [5]:6,[6]:5比较 互换 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]


    左向冒泡第1次 [4]:4,[5]:5比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    左向冒泡第2次 [3]:3,[4]:4比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第5轮
    右向冒泡第1次 [4]:4,[5]:5比较 不变 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]



排序后:  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=====结束=====