精华内容
下载资源
问答
  • 下面代码是冒泡排序逐步优化,写代码用递归也可以实现。什么冒泡排序就不写了,百度解释很详细。对理论不是很感兴趣。#!/usr/bin/env python3# -*- coding: utf-8 -*-"""===========================# @Time : 2020...

    下面代码是冒泡排序逐步优化,写代码用递归也可以实现。什么冒泡排序就不写了,百度解释很详细。对理论不是很感兴趣。

    #!/usr/bin/env python3

    # -*- coding: utf-8 -*-

    """

    ===========================

    # @Time : 2020/9/19 19:54

    # @File : 冒泡排序.py

    # @Author: adeng

    # @Date : 2020/9/19

    ============================

    """

    import random,time

    list_nums = random.sample(range(0,20000,3),12)

    print(list_nums)

    #---------------------for循环------------------

    count = 0

    for i in range(len(list_nums)):

    pass

    flag = True

    for j in range(len(list_nums)-1-i):

    count += 1

    if list_nums[j] > list_nums[j+1]:

    flag = False

    list_nums[j], list_nums[j+1] = list_nums[j+1], list_nums[j]

    if flag:

    break

    print(list_nums)

    # 查看比较多少次

    print("比较的次数为{}".format(count))

    #-------------------------while循环---------------------

    i = 0

    count =0

    while i < len(list_nums):

    j = 0

    while j< len(list_nums)-1 -i:

    count += 1

    if list_nums[j] > list_nums[j + 1]:

    list_nums[j], list_nums[j+1] = list_nums[j+1], list_nums[j]

    j += 1

    i += 1

    print(list_nums)

    print("比较的次数为{}".format(count))

    # 优化冒泡排序

    # ---------------------------优化冒泡排序------------

    i = 0

    count1 =0

    start_time = time.time()

    while i < len(list_nums):

    flag = True # 假设每一趟都没有换行

    j = 0

    while j< len(list_nums)-1 -i:

    count1 += 1

    if list_nums[j] > list_nums[j + 1]:

    list_nums[j], list_nums[j+1] = list_nums[j+1], list_nums[j]

    flag = False # 交换了大小,flag为False

    j += 1

    if flag:

    # 这一趟走完以后,flag依然为True,说明这一趟没有进行数据交换

    break

    i += 1

    end_time = time.time()

    print(f"冒牌排序花费时间{end_time-start_time}秒")

    print(list_nums)

    print("比较的次数为{}".format(count1))

    #------------------------递归----------------------------------

    from typing import List

    def array_init(array: List[int], n:int) -> List:

    i = 0

    j = 1

    while j < len(array):

    if array[i] > array[j]:

    array[i], array[j] = array[j], array[i]

    i += 1

    j += 1

    if n == 1:

    # print("array:",array)

    return array

    return array_init(array, n - 1)

    start_time = time.time()

    print(array_init(list_nums, len(list_nums)))

    end_time = time.time()

    print(f"冒牌排序花费时间{end_time-start_time}秒")

    # ------------------------------封装---------------

    def get_random_list(num:int,length)-> list:

    """

    获取一个随机列表

    @param array: 列表

    @return: 返回一个列表

    """

    return random.sample(range(num),length)

    def sort_iter(list_num:list,reverse=False) -> list:

    """

    @param list_num: 列表排序

    @param reverse: False 升序 True 降序

    @return: 返回列表

    """

    global count

    count = 0

    for i in range(len(list_num)):

    pass

    flag = True

    for j in range(len(list_num) - 1 - i):

    count += 1

    if not reverse:

    if list_num[j] > list_num[j + 1]:

    flag = False

    list_num[j], list_num[j + 1] = list_num[j + 1], list_num[j]

    else:

    if list_num[j] < list_num[j + 1]:

    flag = False

    list_num[j], list_num[j + 1] = list_num[j + 1], list_num[j]

    if flag:

    break

    return list_num

    print(sort_iter([3,2,1,10,8,3,6,],reverse=True),count)

    def sort_lists(list_num:list,reverse=False) ->list:

    """

    @param list_num: 列表,元素要是int类型

    @param reverse: False 升序,True降序

    @return: 返回列表

    """

    i = 0

    count = 0 # 统计比较了多少次

    while i < len(list_num):

    flag = True # 假设每一趟都没有换行

    j = 0

    while j < len(list_num) - 1 - i:

    count += 1

    if not reverse:

    if list_num[j] > list_num[j + 1]:

    list_num[j], list_num[j + 1] = list_num[j + 1], list_num[j]

    flag = False # 交换了大小,flag为False

    else:

    if list_num[j] < list_num[j + 1]:

    list_num[j], list_num[j + 1] = list_num[j + 1], list_num[j]

    flag = False # 交换了大小,flag为False

    j += 1

    if flag:

    # 这一趟走完以后,flag依然为True,说明这一趟没有进行数据交换

    break

    i += 1

    return list_num

    a = [3,1,5,6,4,3,0]

    sort_lists(a,reverse=True)

    print(a) # [6, 5, 4, 3, 3, 1, 0]

    展开全文
  • 1.冒泡排序(从大到小):交换发生在内部循环稳定的排序冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)冒泡排序优化在于didswap变量 ,通过这个变量的设置,...

    1.冒泡排序(从大到小):交换发生在内部循环

    稳定的排序

    冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)

    冒泡排序的优化在于didswap变量 ,通过这个变量的设置,实现冒泡排序的最好时间复杂度是O(n)

    #!usr/bin/python

    arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56,76,34,657,34,45,56,23]

    def BubbleSort(list):

    for i in range(len(list)-1):

    didswap = False

    for j in range(len(list)-1-i):

    if list[j]

    list[j],list[j+1]=list[j+1],list[j]

    didswap =True

    if didswap == False:

    return list

    return list

    print (BubbleSort(arr))

    2.选择排序(从大到小):交换发生在外部循环

    不稳定的排序

    平均算法复杂度O(n2),最好算法复杂度O(n2),最坏的算法复杂度为O(n2),空间复杂度O(1)

    #!usr/bin/python

    defSelectSort(lists):

    for i in range(len(lists)-1):

    max=i

    for j in range(i+1,len(lists)):

    if lists[j]>lists[max]:

    max=j

    lists[max],lists[i]=lists[i],lists[max]

    returnlists

    lists=[2,3,4,65,7,6,5,5,6,7,8,6,4]

    print SelectSort(lists)

    3.插入排序(从大到小排序):

    稳定的排序

    平均复杂度O(n2),最好的时间复杂度O(n),最坏的算法复杂度O(n2),空间复杂度是O(1)

    #!usr/bin/python

    defInsertSort(lists):for i in range(1,len(lists)):

    key=lists[i]

    j=i-1

    while j>=0 and lists[j]

    lists[j+1]=lists[j]

    j=j-1lists[j+1]=keyreturnlists

    arr=[2,3,4,5,6,8,7,5,6,7,6,4,5,6,7,8,7,5]print InsertSort(arr)

    4.归并排序(从大到小):归并排序的思想就是分而治之

    归并排序是稳定

    平均O(nlgn) 最好的时间复杂度是O(nlgn),最坏的时间复杂度是O(nlgn),空间复杂度是O(n)

    #!usr/bin/python

    defMerge(left,right):

    i,j=0,0

    result=[]while i=right[j]:

    result.append(left[i])

    i+=1

    else:

    result.append(right[j])

    j+=1result+=left[i:]

    result+=right[j:]returnresultdefMergeSort(lists):if len(lists)<2:returnlists

    div= len(lists)/2left=MergeSort(lists[0:div])

    right=MergeSort(lists[div:])returnMerge(left,right)

    lists= [2,3,4,5,6,7,6,5,34,23,4,56,6,3,4,6]print MergeSort(lists)

    5.快速排序:(递归调用)

    平均时间复杂度O(nlgn),平均时间复杂度O(nlgn),最坏的时间复杂度O(n2)

    空间复杂度O(lgn)-Olg(n)

    def QuickSort(myList,start,end):

    #判断low是否小于high,如果为false,直接返回

    if start < end:

    i,j = start,end

    #设置基准数

    base = myList[i]

    while i < j:

    #如果列表后边的数,比基准数大或相等,则前移一位直到有比基准数小的数出现

    while (i < j) and (myList[j] >= base):

    j = j - 1

    #如找到,则把第j个元素赋值给第个元素i,此时表中i,j个元素相等

    myList[i] = myList[j]

    #同样的方式比较前半区

    while (i < j) and (myList[i] <= base):

    i = i + 1

    myList[j] = myList[i]

    #做完第一轮比较之后,列表被分成了两个半区,并且i=j,需要将这个数设置回base

    myList[i] = base

    #递归前后半区

    QuickSort(myList, start, i - 1)

    QuickSort(myList, j + 1, end)

    return myList

    lists = [49,38,65,97,76,13,27,49]

    print(QuickSort(lists,0,len(lists)-1))

    print (lists)

    7.堆排序(从大到小):第一步最小堆化;第二步建立最小堆;第三步堆排序

    #!user/bin/python

    defAjustHeap(lists,i,size):

    min=i

    left=2*i+1right=2*i+2

    if i < size/2:if right < size and lists[min] >lists[right]:

    min=rightif left < size and lists[min]>lists[left]:

    min=leftif min!=i:

    lists[i],lists[min]=lists[min],lists[i]

    AjustHeap(lists,min,size)defBuildHeap(lists,size):for i in range(0,(size/2))[::-1]:

    AjustHeap(lists,i,size)defHeapSort(lists):

    size=len(lists)

    BuildHeap(lists,size)for i in range(0,size)[::-1]:

    lists[i],lists[0]=lists[0],lists[i]

    AjustHeap(lists,0,i)returnlists

    arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]print HeapSort(arr)

    6.希尔排序(从大到小):(插入排序的一种)

    #!user/bin/python

    defShellSort(lists):

    step=len(lists)/2

    while (step>=1):#step终止循环为1

    for i in range(step,len(lists)):#没一次step对应很多个新列表

    while(i>=step and lists[i] > lists[i-step]):#每个列表进行排序

    lists[i],lists[i-step]=lists[i-step],lists[i]

    i=i-step

    step=step/2

    returnlists

    arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]

    print ShellSort(arr)

    8.计数排序:

    展开全文
  • #优化冒泡排序python) ''' 记录交换操作发生的位置,如果没有发生交换操作,则代表排序已经可以终止 这样一来冒泡排序最好的情况下,时间复杂度就从O(n^2)优化到了O(n) ''' def imroved_bubble_sort(l): length =...

    优化冒泡排序(python)

    '''
    记录交换操作发生的位置,如果没有发生交换操作,则代表排序已经可以终止
    这样一来冒泡排序最好的情况下,时间复杂度就从O(n^2)优化到了O(n)
    '''
    def imroved_bubble_sort(l):
        length = len(l)
        swaplast = length - 1
        for i in range(len(l)):
            sign = swaplast
            for j in range(swaplast):
                if l[j] > l[j+1]:
                    temp = l[j+1]
                    l[j + 1] = l[j]
                    l[j] = temp
                    swaplast = j
            if sign == swaplast:
                break
    
    展开全文
  • 1.冒泡排序(从大到小):交换发生在内部循环稳定的排序冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)冒泡排序优化在于didswap变量 ,通过这个变量的设置,...

    1.冒泡排序(从大到小):交换发生在内部循环

    稳定的排序

    冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)

    冒泡排序的优化在于didswap变量 ,通过这个变量的设置,实现冒泡排序的最好时间复杂度是O(n)

    #!usr/bin/python

    arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56,76,34,657,34,45,56,23]

    def BubbleSort(list):

    for i in range(len(list)-1):

    didswap = False

    for j in range(len(list)-1-i):

    if list[j]

    list[j],list[j+1]=list[j+1],list[j]

    didswap =True

    if didswap == False:

    return list

    return list

    print (BubbleSort(arr))

    2.选择排序(从大到小):交换发生在外部循环

    不稳定的排序

    平均算法复杂度O(n2),最好算法复杂度O(n2),最坏的算法复杂度为O(n2),空间复杂度O(1)

    #!usr/bin/python

    defSelectSort(lists):

    for i in range(len(lists)-1):

    max=i

    for j in range(i+1,len(lists)):

    if lists[j]>lists[max]:

    max=j

    lists[max],lists[i]=lists[i],lists[max]

    returnlists

    lists=[2,3,4,65,7,6,5,5,6,7,8,6,4]

    print SelectSort(lists)

    3.插入排序(从大到小排序):

    稳定的排序

    平均复杂度O(n2),最好的时间复杂度O(n),最坏的算法复杂度O(n2),空间复杂度是O(1)

    #!usr/bin/python

    defInsertSort(lists):for i in range(1,len(lists)):

    key=lists[i]

    j=i-1

    while j>=0 and lists[j]

    lists[j+1]=lists[j]

    j=j-1lists[j+1]=keyreturnlists

    arr=[2,3,4,5,6,8,7,5,6,7,6,4,5,6,7,8,7,5]print InsertSort(arr)

    4.归并排序(从大到小):归并排序的思想就是分而治之

    归并排序是稳定

    平均O(nlgn) 最好的时间复杂度是O(nlgn),最坏的时间复杂度是O(nlgn),空间复杂度是O(n)

    #!usr/bin/python

    defMerge(left,right):

    i,j=0,0

    result=[]while i=right[j]:

    result.append(left[i])

    i+=1

    else:

    result.append(right[j])

    j+=1result+=left[i:]

    result+=right[j:]returnresultdefMergeSort(lists):if len(lists)<2:returnlists

    div= len(lists)/2left=MergeSort(lists[0:div])

    right=MergeSort(lists[div:])returnMerge(left,right)

    lists= [2,3,4,5,6,7,6,5,34,23,4,56,6,3,4,6]print MergeSort(lists)

    5.快速排序:(递归调用)

    平均时间复杂度O(nlgn),平均时间复杂度O(nlgn),最坏的时间复杂度O(n2)

    空间复杂度O(lgn)-Olg(n)

    def QuickSort(myList,start,end):

    #判断low是否小于high,如果为false,直接返回

    if start < end:

    i,j = start,end

    #设置基准数

    base = myList[i]

    while i < j:

    #如果列表后边的数,比基准数大或相等,则前移一位直到有比基准数小的数出现

    while (i < j) and (myList[j] >= base):

    j = j - 1

    #如找到,则把第j个元素赋值给第个元素i,此时表中i,j个元素相等

    myList[i] = myList[j]

    #同样的方式比较前半区

    while (i < j) and (myList[i] <= base):

    i = i + 1

    myList[j] = myList[i]

    #做完第一轮比较之后,列表被分成了两个半区,并且i=j,需要将这个数设置回base

    myList[i] = base

    #递归前后半区

    QuickSort(myList, start, i - 1)

    QuickSort(myList, j + 1, end)

    return myList

    lists = [49,38,65,97,76,13,27,49]

    print(QuickSort(lists,0,len(lists)-1))

    print (lists)

    7.堆排序(从大到小):第一步最小堆化;第二步建立最小堆;第三步堆排序

    #!user/bin/python

    defAjustHeap(lists,i,size):

    min=i

    left=2*i+1right=2*i+2

    if i < size/2:if right < size and lists[min] >lists[right]:

    min=rightif left < size and lists[min]>lists[left]:

    min=leftif min!=i:

    lists[i],lists[min]=lists[min],lists[i]

    AjustHeap(lists,min,size)defBuildHeap(lists,size):for i in range(0,(size/2))[::-1]:

    AjustHeap(lists,i,size)defHeapSort(lists):

    size=len(lists)

    BuildHeap(lists,size)for i in range(0,size)[::-1]:

    lists[i],lists[0]=lists[0],lists[i]

    AjustHeap(lists,0,i)returnlists

    arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]print HeapSort(arr)

    6.希尔排序(从大到小):(插入排序的一种)

    #!user/bin/python

    defShellSort(lists):

    step=len(lists)/2

    while (step>=1):#step终止循环为1

    for i in range(step,len(lists)):#没一次step对应很多个新列表

    while(i>=step and lists[i] > lists[i-step]):#每个列表进行排序

    lists[i],lists[i-step]=lists[i-step],lists[i]

    i=i-step

    step=step/2

    returnlists

    arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]

    print ShellSort(arr)

    8.计数排序:

    展开全文
  • 一、冒泡排序简介冒泡排序(Bubble Sort)是一种常见的排序算法,相对来说比较简单。冒泡排序重复地走访需要排序的元素列表,依次比较两个相邻的元素,如果顺序(如从大到小或从小到大)错误就交换它们的位置。重复地...
  • 说到算法中的排序,冒泡排序是最简单的一种排序算法了,甚至不学数据结构与算法的同学都会使用它。但是你有没有想过可以怎么优化?什么是冒泡排序:就像水慢慢烧开,气泡从下往上越来越大那样,第一次循环都把n个...
  • 冒泡排序原理 从第一个元素开始(可以从第一个,也可以从最后一个),相邻两两元素进行比较大小,将较大的那个往后移动,否则,两个元素位置...根据冒泡排序的定义,我们可以用python代码实现 def bubble_sort(it...
  • 1.冒泡排序(从大到小):交换发生在内部循环 ...冒泡排序优化在于didswap变量 ,通过这个变量的设置,实现冒泡排序的最好时间复杂度是O(n) #!usr/bin/python arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56...
  • 冒泡排序优化3.冒泡排序最终优化总结 原理 冒泡排序是一种交换排序,核心是冒泡,把数组中最小的那个往上冒,冒的过程就是和他相邻的元素交换。 重复走访要排序的数列,通过两两比较相邻记录的排序码。排序过程中...
  • 冒泡排序1、题目假设有一个列表 list = [5,4,3,2,1]要求:按从小到大的顺序排序2、分析● 冒泡排序的思路两两比较,互换位置,每一轮选出最大(小)的数放到列尾● 图解① 第一轮比较第一轮比较② 第二轮比较③ 第三轮...
  • 我对Python相当陌生,我将从...我建议第一个选项是优化冒泡排序,但第二个选项有问题。在维基百科中,这个“允许我们跳过很多元素,结果在最坏的情况下,比较计数提高了大约50%”。所以我的第一个选项的代码看起来...
  • Python 算法 08 -- 冒泡排序及其优化-1.jpg (93.27 KB, 下载次数: 0)2020-11-6 21:31 上传Python 算法 08 -- 冒泡排序及其优化-2.jpg (56.14 KB, 下载次数: 0)2020-11-6 21:31 上传冒泡排序1、题目假设有一个列表 ...
  • 近期很多童鞋在讨论大厂面试的算法题,有部分同学表示一脸懵逼,不知从何下手,还有一一部分同学写的冒泡排序算法是直接从网上复制下来的冒泡排序,大多数都没有考虑时间复杂度,说白了只是实现了冒泡的流程,严格来...
  • 1.冒泡排序 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该...
  • python冒泡排序优化

    2021-04-15 09:36:04
    优化的关键点 是对 有序区的 界定(在哪里开始有序) 我们在每一轮排序后,记录下最后一次元素交换的位置,那 该位置就是 无序区的边界 ,再往后 就是有趣 ‘’’ def sort_bubble(tmp_list): # 记录最后一次交换...
  • 1.冒泡排序是最基础的排序方式,使用两次for循环完成,内层循环比较两个相邻元素的大小,一次循环完找出最大的元素放在最后,外层循环有多少个待排元素,循环多少遍,这样两层循环完乱序的列表就排序好了,第一次...
  • 普通版:def bubble_sort(nums):for i in range(len(nums) - 1):for j in range(len(nums... nums[j + 1]:nums[j], nums[j + 1] = nums[j + 1], nums[j]return nums动态展示一下冒泡排序过程:image.png假设现在有一...
  • 文章目录:概念实现一次冒泡的算法普通冒泡排序算法优化冒泡排序算法总结 利用Python实现数据结构中的冒泡排序。 运行平台: Windows Python版本: Python 3.8 IDE: Pycharm 概念        ...
  • python冒泡排序程序

    2018-02-04 20:35:54
    python冒泡排序程序,优化代码。。,python冒泡排序程序python冒泡排序程序python冒泡排序程序python冒泡排序程序python冒泡排序程序
  • 冒泡排序算法(原理) 比较相邻的元素。如果第一个比第二个大,就交换他们两个。最后的元素应是最大的数。 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。 针对所有的元素重复以上的步骤,除了...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 215
精华内容 86
关键字:

冒泡排序优化python

python 订阅