精华内容
下载资源
问答
  • python冒泡排序算法

    千次阅读 2019-04-11 11:24:20
    冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,一层一层的将较大的元素往后移动,其现象气泡在上升过程中慢慢变大类似,故成为冒泡...
    1. 冒泡排序

    冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,一层一层的将较大的元素往后移动,其现象和气泡在上升过程中慢慢变大类似,故成为冒泡排序。

    def bubble_sort(arr):
        """冒泡排序"""
        # 第一层for表示循环的遍数,表示总得长度,代表每个元素遍历次数
        for i in range(len(arr) - 1):
            # 第二层for表示具体比较哪两个元素,根据每个元素从第一到最后0-j 进行排序
            for j in range(len(arr) - 1 - i):
                if arr[j] > arr[j + 1]:
                    # 如果前面的大于后面的,则交换这两个元素的位置
                    arr[j], arr[j + 1] = arr[j + 1], arr[j]
        print(arr)
        return arr
    
        return arr
    if __name__ == '__main__':
        arr = [7,6,5,4,3,2,1]
        bubble_sort(arr)

    冒泡排序是一种简单直接暴力的排序算法,为什么说它暴力?因为每一轮比较可能多个元素移动位置,而元素位置的互换是需要消耗资源的,所以这是一种偏慢的排序算法,仅适用于对于含有较少元素的数列进行排序。

    1. 稳定性:我们从代码中可以看出只有前一个元素大于后一个元素才可能交换位置,所以相同元素的相对顺序不可能改变,所以它是稳定排序
    2. 比较性:因为排序时元素之间需要比较,所以是比较排序
    3. 时间复杂度:因为它需要双层循环n*(n-1)),所以平均时间复杂度为O(n^2)
    4. 空间复杂度:只需要常数个辅助单元,所以空间复杂度为O(1),我们把空间复杂度为O(1)的排序成为原地排序(in-place)
    5. 记忆方法:想象成气泡,一层一层的往上变大
    展开全文
  • Python算法冒泡排序和选择排序冒泡排序:重复地走访过要排序的元素列,依次比较两个相邻的元素,一层一层的将较大的元素往后移动,类似气泡慢慢变大的过程。 算法思想:1.从第一个第二个开始比较,如果第一...

    Python算法(冒泡排序和选择排序)

    冒泡排序:重复地走访过要排序的元素列,依次比较两个相邻的元素,一层一层的将较大的元素往后移动,类似气泡慢慢变大的过程。

    算法思想:1.从第一个和第二个开始比较,如果第一个比第二个大,则交换位置;然后比较第二个和第三个,依次类推;
    2.经过第一轮循环,最大的数已经排在最后一位,所以重复以上操作,第二大的数会排在倒数第二个位置。
    3.则再重复n-1次排序完毕,因为最后一个数字不需要排序了。

    算法实现:

    1.首先生成一个随机数的列表

    import random
    
    random_num_list = random.sample(range(1, 100), 20)
    print(random_num_list)
    
    [66, 70, 16, 98, 97, 52, 56, 76, 23, 27, 36, 38, 2, 47, 11, 58, 33, 46, 62, 99]
    

    2.排序

    #经过一轮排序,最大的数字移到最后一位。
    for j in range(len(random_num_list)-1):
        if random_num_list[j] > random_num_list[j+1]:
            random_num_list[j], random_num_list[j+1] = random_num_list[j+1], random_num_list[j]
    print(random_num_list)
    
    [66, 16, 70, 97, 52, 56, 76, 23, 27, 36, 38, 2, 47, 11, 58, 33, 46, 62, 98, 99]
    
    #经过n-1次上述过程,排序完成。
    for i in range(len(random_num_list)-1):
        for j in range(len(random_num_list)-1):
            if random_num_list[j] > random_num_list[j+1]:
                random_num_list[j], random_num_list[j+1] = random_num_list[j+1], random_num_list[j]
    print(random_num_list)
    
    [2, 11, 16, 23, 27, 33, 36, 38, 46, 47, 52, 56, 58, 62, 66, 70, 76, 97, 98, 99]
    

    选择排序:由于冒泡排序每次都要进行交换位置,浪费内存,又有了选择排序。

    算法思想:1.将第一个数字设为最小值,依次和后面的数字进行比较,当有比第一个数字小的数,则把最小值的索引置为该数字的索引,比较完之后,将最小值索引对应的数字和第一位交换;2.经过一轮操作,最小数排在第一位,然后将第二个数字设为最小值,以此类推;3.同样地,经过n-1次,排序完成。

    算法实现:

    random_num_list = random.sample(range(1, 50), 20)
    print(random_num_list)
    #将最小的数排在第一位
    i = 0 
    minimal_index = i
    for j in range(i+1, len(random_num_list)):
        if random_num_list[j] < random_num_list[minimal_index]:
            minimal_index = j
    random_num_list[i], random_num_list[minimal_index] = random_num_list[minimal_index], random_num_list[i]
    print(random_num_list)
    
    [7, 31, 26, 23, 48, 15, 18, 1, 49, 41, 3, 30, 44, 36, 24, 42, 17, 12, 38, 39]
    [1, 31, 26, 23, 48, 15, 18, 7, 49, 41, 3, 30, 44, 36, 24, 42, 17, 12, 38, 39]
    
    for i in range(len(random_num_list)):
        minimal_index = i
        for j in range(i+1, len(random_num_list)):
            if random_num_list[j] < random_num_list[minimal_index]:
                minimal_index = j
        random_num_list[i], random_num_list[minimal_index] = random_num_list[minimal_index], random_num_list[i]
    print(random_num_list)
    
    [1, 3, 7, 12, 15, 17, 18, 23, 24, 26, 30, 31, 36, 38, 39, 41, 42, 44, 48, 49]
    

    学习于裸睡的猪公众号,侵删。

    展开全文
  • 冒泡排序,是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。具体操作参考...

    冒泡排序,是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。具体操作参考wiki。代码如下:

    def bubble_sort(list2):
        #swap_test = False
        for i in range(0, len(list2) - 1):
            # as suggested by kubrick, makes sense
            swap_test = False
            for j in range(0, len(list2) - i - 1):
                if list2[j] > list2[j + 1]:
                    list2[j], list2[j + 1] = list2[j + 1], list2[j]  # swap
                    swap_test = True
            if swap_test == False:
                break

    选择排序,是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。具体操作参考wiki。代码如下:

    def selection_sort(list2):
        for i in range(0, len (list2)):
            min = i
            for j in range(i + 1, len(list2)):
                if list2[j] < list2[min]:
                    min = j
            list2[i], list2[min] = list2[min], list2[i]  # swap

    以上方法测试很简单:

    >>> lst1 = [6,4,9,0,3,2]
    >>> selection_sort(lst1)
    >>> lst1
    [0, 2, 3, 4, 6, 9]



    展开全文
  • 一、冒泡排序(Bubble sort) Bubble sort, sometimes referred to assinking sort, is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items ...

    一、冒泡排序(Bubble sort)

    Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items and swaps them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted.

    Properties

    • Worst case performance O(n2)
    • Best case performance O(n)
    • Average case performance O(n2)
    #冒泡排序,将一个数组进行从小到大进行排序
    array_a= [80, 24, 28, 33, 19, 44, 8, 17, 22, 16, 12]#定义一个数组,define a array
    array_b=[88,21,19,17,19,22,44,28,22,10,5,6]#定义一个数组 define a array
    def bubble_sort_min(array_sort): #定义一个buuble_sort函数,该函数参数为数组,返回值为从小到大排序的数组。define a function,the fuction has a array parameter.
    #loop_count=0
    for i in range(len(array_sort)-1): #数组个数有11个,那么使用冒泡排序需要循环11-1次。n个数,循环n-1次
    #print("i=",i)
    #print("leni=",len(array_sort)-1)
    for j in range(len(array_sort)-i-1): #每循环一次,两两比较,找到最大值放到数组中最后一个位置。第一次循环需要比较10次,第二次比较9次,第三次比较8次...。第一次循环n-1次,第二次循环n-2次,第n-1次循环1次
    #print("j=",j)
    #print("lenj=", len(array_sort)-i-1)
    if array_sort[j]>array_sort[j+1]:#比较两个相邻数组元素的大小
    array_sort[j],array_sort[j+1]=array_sort[j+1],array_sort[j]#如果前面的大就交换位置
    #loop_count+=1
    print("loop_count=", loop_count) #循环次数为n(n+1)/2次
    return array_sort#返回排序好的数组 return a new array.
    def bubble_sort_max(array_sort): #定义一个buuble_sort函数,该函数参数为数组,返回值为从大到小排序的数组。define a function,the fuction has a array parameter.
    for i in range(len(array_sort)-1): #数组个数有11个,那么使用冒泡排序需要循环11-1次。n个数,循环n-1次
    for j in range(len(array_sort)-i-1): #每循环一次,两两比较,找到最大值放到数组中最后一个位置。第一次循环需要比较10次,第二次比较9次,第三次比较8次...。
    if array_sort[j]<array_sort[j+1]:#比较两个相邻数组元素的大小
    array_sort[j],array_sort[j+1]=array_sort[j+1],array_sort[j]#如果前面的小就交换位置
    return array_sort#返回排序好的数组 return a new array.
    bubble_sort_min(array_a)#调用函数 call bubble_sort function
    #bubble_sort(array_b)#调用函数
    bubble_sort_max(array_b)
    print("array_a=",array_a)#打印输出第一个排好序的数组 print array
    print("array_b=",array_b)#打印输出第二个排好序的数组

    二、选择排序(Selection sort)

    The algorithm works by selecting the smallest unsorted item and then swapping it with the item in the next position to be filled.
    The selection sort works as follows: you look through the entire array for the smallest element, once you find it you swap it
    (the smallest element) with the first element of the array. Then you look for the smallest element in the remaining array
    (an array without the first element) and swap it with the second element. Then you look for the smallest element in the remaining
    array (an array without first and second elements) and swap it with the third element, and so on. Here is an example,
    array_a=[33,32,31,30,29,28,27,26,25,24,23]
    #array_a=[23,21,11,33,34,12,45,17]
    small_num_index=0 #初始列表下标,默认是数组的第一个元素的下标,也就是array_a[0]
    loop_count=0 #统计循环共执行了次数。
    swap_count=0 #统计排序时数组元素的值实际交换的次数
    for i in range(len(array_a)-1): #大循环,循环的次数应该等于数组个数n减去1次,即n-1次
    print("small_num_index3=", small_num_index) #每次循环时最小值下标值,第一次循环为0,第二次循环为1,第三次循环为2....
    for j in range(i,len(array_a)): #小循环,小循环的开始下标值为大循环下标,结束为数组长度-1
    if array_a[j]<array_a[small_num_index]: #如果该数组元素比每次最小下标数组元素的值小则将最小下标值改为该元素下标
    small_num_index=j
    swap_count+=1
    loop_count+=1
    else:
    print("the smallest num is:", array_a[small_num_index]) #每次执行完后找到最小值得数组元素
    print("small_num_index1=",small_num_index)
    array_a[small_num_index],array_a[i]=array_a[i],array_a[small_num_index] #将最小下标元素和最小值元素的值互换,即将最小值放在每次小循环最小下标内。
    small_num_index=i+1 #将最小值下标设置为下一次循环下标最小值
    print("small_num_index2=", small_num_index)
    print("array_a selection_sort:",array_a)
    print("swap_count=",swap_count)
    print("loop_count=",loop_count) #循环次数为(n+2)(n-1)/2 次

    三、两个排序的区别联系

    1.冒泡排序是通过数组相邻元素两两比较,大的排后面,一次比较找到整个数组最大值放在数组最后一个位置。小循环时,通过控制小循环的循环下标range j=len(array)-i-1忽略掉数组最后已经排列好的一个元素,从后往前直到最前面。

    2.选择排序是通过从前往后,从第一个数组元素和后面的元素比较,如果后面的元素小,就把该元素的值和后面的继续比较,找到最小值后,和第一个数组元素的值交换,把最小值放到数组的第一个位置。然后通过控制小循环的下标(j in range(i,len(array)))忽略掉第一个已经排好序的数组元素,从第二个元素开始继续循环找到第二小值,放到第二个元素上,以此类推,直至最后。

    3.选择排序因每次循环直接找到最小值,因此需要一个变量small_num_index来记录最小值的数组元素下标。而冒泡因是两两比较,每次将大的值放到后面,所以不需要额外的变量。

    4.冒泡排序执行循环次数为n(n+1)/2次,选择排序执行循环次数(n+2)(n-1)/2 次。

     

    转载于:https://www.cnblogs.com/xsfy/p/10788466.html

    展开全文
  • 前言 今天整理文件时,发现了这部分排序内容,冒泡排序插入排序的算法实现,在我刚接触...冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如
  •  冒泡排序就是每次找出最大(最小)元素,放在集合最前或最后,这是最简单的排序算法 print("未排序之前:",collection)#不能写成+(会提示为不是str类型数据,要写成这样) #升序排列 temp=collection[0] ...
  •  Python数据结构之冒泡排序 冒泡排序是一种基础排序算法,在python中,我们利用列表的的方式来完成,它对列表中的元素进行重复的遍历,在遍历的同时进行比较,如果两个数没有按照我们规定的顺序进行排列,就按照...
  • 冒泡排序算法的C++,Java和Python实现和冒泡排序算法三种语言效率的比较 冒泡排序原理: 这一篇百度经验讲得很好,我不多说了 https://jingyan.baidu.com/article/6525d4b13f920bac7d2e9484.html ...
  • 万众期待的排序算法终于来啦 今天开始排序算法的学习 第一个是冒泡排序 冒泡排序的核心思想是相邻的两个数据进行比较 假设A有n个数据,先比较第1个第2个数据,如果A1>A2 就交换他们的位置,确保较大的的那个数...
  • 也就是如果一个排序算法是稳定的,当有两个相等键值的纪录RS,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前。 不稳定排序算法可能会在相等的键值中改变纪录的相对次序,但是稳定排序算法从来...
  • 冒泡排序是一种交换排序,核心是冒泡,把数组中最小的那个往上冒,冒的过程就是他相邻的元素交换。 重复走访要排序的数列,通过两两比较相邻记录的排序码。排序过程中每次从后往前冒一个最小值,且每次能确定一个...
  • 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序...
  • 冒泡排序 顾名思义,冒泡排序直观的意思是气泡越大冒的越快:),对应到我们的列表中就是数字最大的先选出来,然后依次进行。例如 myList=[1,4,5,0,6],比较方式为:  相邻的两个数字先进行比较,也就是myList[0]...
  • 冒泡排序 原理 相邻的两个数值进行比较,第二个比第一个大,(他们直接就交换顺序,一直比到最后一个数) 列表:a=[1,8,7,5,3] 第一轮比较: 第二轮比较 第三轮比较: 第四轮比较 得出结论: 程序的实现 def ...
  • 冒泡排序算法 花费时间很多的一种排序算法 我们有 a1,a2…an个数据, a1a2比较 如果a1>a2 a1 a2交换位置 然后a2 a3 比较,一直比到 an。 这是一次轮回,每次轮回,an都是最大(或最小,根据a1 a2的判断条件...
  • 目录一、冒泡排序(Bubble Sort)1.1 算法思路1.2 算法分析二、选择排序2.1 算法思路及分析 一、冒泡排序(Bubble Sort) 1.1 算法思路 在于对无序表进行多趟比较交换,每趟包括了多次两两相邻比较, 并将逆序的数据...
  • python算法-冒泡排序

    2018-08-22 11:13:00
    核心算法: ...直到完成所有的排序,由于每次都是把最大的排到最后面,就好像冒泡一样,故取名冒泡排序。 详细讲解: 里层for循环的逻辑: 第一步:从第一个元素开始,与第二个元素比较,如果小于,则...
  • python实现冒泡排序算法,代码简单解释如下 def bubble_sort(numbers): length = len(numbers)#列表长度 for i in range(length - 1):#需要遍历次数 for j in range(length - i - 1):#每次遍历,比较的数列元素...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 707
精华内容 282
关键字:

python冒泡算法和排序算法

python 订阅