精华内容
下载资源
问答
  • Python 冒泡排序

    万次阅读 2019-11-27 20:04:30
    Python 冒泡排序 基本原理: 相邻的元素比较,如果前一个元素大于后一个元素,则交换位置。 第一次遍历后,最大的元素会移动到最后的位置。 第二次遍历只需要比较前len(array)-i-1个元素,因为后面的元素肯定...

    Python 冒泡排序

    基本原理:

    1. 相邻的元素比较,如果前一个元素大于后一个元素,则交换位置。

    2. 第一次遍历后,最大的元素会移动到最后的位置。

    3. 第二次遍历只需要比较前len(array)-i-1个元素,因为后面的元素肯定都比前面的元素大。

    时间复杂度为O(n^2) n为数组元素的个数。

    空间复杂度为O(1)

    因为没有创建新的数组,所以是一个稳定的算法。
    网络上的冒泡排序图片
    该图片来源于网络

    冒泡排序

    def bubble_sort(array):
        """
        冒泡排序
        
        :param array: 数组
        :return: 已排序的数组
        """
        length = len(array)
        for i in range(length - 1):
            # 改进措施. 如果一次循环完了之后没有进行交换,说明array本身就有序.后续循环无需再做.
            swapped = False
            for j in range(length - i - 1):
                # 比较相邻的两个元素
                if array[j] > array[j + 1]:
                    # 交换位置
                    array[j], array[j + 1] = array[j + 1], array[j]
                    swapped = True
            if not swapped:
                break
        return array
    展开全文
  • python冒泡排序

    2019-03-27 21:29:35
    python冒泡排序冒泡排序冒泡排序的方法算法设计代码 冒泡排序 了解数据结构与算法是程序员的基本功之一,尽管工作中可能永远都用不上,但每一行代码都渗透着数据结构与算法的思想。 冒泡排序的方法 1、循环比较相邻...

    冒泡排序

    了解数据结构与算法是程序员的基本功之一,尽管工作中可能永远都用不上,但每一行代码都渗透着数据结构与算法的思想。

    冒泡排序的方法

    1、循环比较相邻的两个元素,大的向后移动,这样一次循环之后最大的值就放在了最后;
    2、再次进行循环,将次大的数放在倒数第二位;
    3、重复第二步,直至剩余一个数据。

    算法设计

    第一层循环,循环到当前最大的那个元素的下标
    第二层循环,反复比较相邻的两个元素,直至到达最大元素的下标

    代码

    // 冒泡排序算法
    def bubbleSort(num):
    
        for length in range(len(num)-1,0,-1):
    
            # length 每次遍历需要到达的下标,每次减少一个
    
            for i in range(length):
    
                if num[i] > num[i+1]:
    
                    num[i], num[i+1] = num[i+1], num[i]
    
     
    
    num = [54,26,93,17,77,31,44,55,20]
    
    bubbleSort(num)
    
    print(num)
    

    欢迎收看:如何自学人工智能

    展开全文
  • python 冒泡排序

    2018-08-28 10:23:56
    Python冒泡排序 从前往后冒泡 def bubble_sort(L): for i in range(1,len(L)): # 外层循环控制内层循环次数 # 冒泡排序,第一次内层循环n-1次 # 最后一次循环i=len(L)-1,此时j=0,循环后排序完成 flag = 0 ...

    Python冒泡排序

    第一次比较n-1次,第二次比较n-2次,最后一次比较1次,结果就n(n-1)/2

    稳定排序,平均O(n2),最坏O(n2)

    从前往后冒泡

    def bubble_sort(L):
        for i in range(1,len(L)):
            # 外层循环控制内层循环次数
            # 冒泡排序,第一次内层循环n-1次
            # 最后一次循环i=len(L)-1,此时j=0,循环后排序完成
            flag = 0
            for j in range(len(L)-i):
                if L[j] > L[j+1]:
                    L[j], L[j+1] = L[j+1], L[j]
                    flag = 1
            if not flag:
                break       
    def bubble_sort(L):
        for i in range(len(L)-1):
            flag = 0
            for j in range(len(L)-i-1):
                if L[j] > L[j+1]:
                    L[j], L[j+1] = L[j+1], L[j]
                    flag = 1
            if not flag:
                break       
    def bubble_sort(L):
        flag = 1
        while flag:
            flag = 0
            # 每次循环n-1次,结果就循环(n-1)^2次
            # 反正都是O(n^2),不怕
            for i in range(len(L)-1):
                if L[i] > L[i+1]:
                    L[i], L[i+1] = L[i+1], L[i]
                    flag = 1
    def bubble_sort(L):
        flag = i = 1
        while flag and i < len(L):
            # i取值1到n-1
            flag = 0
            for j in range(len(L)-i):
                if L[j] > L[j+1]:
                    L[j], L[j+1] = L[j+1], L[j]
                    flag = 1
            i += 1      

    从后往前冒泡

    def bubble_sort(L):
        for i in range(len(L)-1):
            # i取值0到n-2,即0到len(L)-2
            # 控制循环次数,从0开始,还是循环n-1次
            flag = 0
            for j in range(len(L)-1,i,-1):
                # 第一次循环,i=0,j从n-1到1
                # 最后一次循环,i=len(L)-2,j此时取len(L)-1,
                # 即n-1,也就是最后一位,循环后排序完成
                if L[j] < L[j-1]:
                    L[j], L[j-1] = L[j-1], L[j]
                    flag = 1
            if not flag:
                break       

    鸡尾酒排序,双向冒泡

    def double_bubble_srot(L):
        for i in range(len(L)//2):
            # i 控制循环次数,n/2次,n为偶数,奇数都可
            # i 从0到n/2-1
            flag = 0
            for j in range(len(L)-i-1):
                if L[j] > L[j+1]:
                    L[j], L[j+1] = L[j+1], L[j]
                    #flag = 1
            for j in range(len(L)-1, i, -1):
                if L[j]< L[j-1]:
                    L[j], L[j-1] = L[j-1], L[j]
                    flag = 1
            if not flag:
                break
    展开全文
  • Python冒泡排序

    2017-03-27 11:34:20
    Python冒泡排序标签(空格分隔):PythonPython冒泡排序:1. 简单的数组排序(写死数组)a=[3,6,9,5,8,1,4] for i in range(len(a)): for j in range(i): if a[j] > a[j + 1]: #从小到大排序(修改为<即为从大到...

    Python冒泡排序:

    1. 简单的数组排序(写死数组)

    
    
        a=[3,6,9,5,8,1,4]
         for i in range(len(a)):
             for j in range(i):
                 if a[j] > a[j + 1]:
                 #从小到大排序(修改为<即为从大到小)
                     a[j], a[j + 1] = a[j + 1], a[j]
    

    2. 根据用户输入执行排序

        a=[]
        num=int(input("请输入数组长度:"))
        for n in range(num):
            arr  = input("请输入要进行排序的数字(回车输入下一个数字):")
            #获取用户输入
            a.append(arr)
            #将用户输入添加到数组
        choose=int(input("请选择排序方式(0——从大到小  1——从小到大):"))
        if choose==0:#判断用户输入
            for i in range(len(a)):
                for j in range(i):
                    if a[j] < a[j + 1]:
                        a[j], a[j + 1] = a[j + 1], a[j]
        if choose==1:
            for i in range(len(a)):
                for j in range(i):
                    if a[j] > a[j + 1]:
                        a[j], a[j + 1] = a[j + 1], a[j]
        print ("排序后的数组为:\n")
        print (a)

    以上程序只是为了完成功能,部分代码有待完善,仅作参考

    展开全文
  • python冒泡排序程序

    2018-02-04 20:35:54
    python冒泡排序程序,优化代码。。,python冒泡排序程序python冒泡排序程序python冒泡排序程序python冒泡排序程序python冒泡排序程序
  • 主要介绍了python冒泡排序简单实现方法,实例分析了Python冒泡排序的简单实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,147
精华内容 7,258
关键字:

python冒泡排序

python 订阅