• 8大排序之Python实现 冒泡排序优化


    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+1]:
    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
    def SelectSort(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]
            return lists
    
    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
    def InsertSort(lists):
            for i in range(1,len(lists)):
                    key=lists[i]
                    j=i-1
                    while j>=0 and lists[j]<key:
                            lists[j+1]=lists[j]
                            j=j-1
                    lists[j+1]=key
            return lists
    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
    def Merge(left,right):
            i,j=0,0
            result=[]
            while i<len(left) and j<len(right):
                    if left[i]>=right[j]:
                            result.append(left[i])
                            i+=1
                    else:
                            result.append(right[j])
                            j+=1
            result+=left[i:]
            result+=right[j:]
            return result
    def MergeSort(lists): if len(lists)<2: return lists div = len(lists)/2 left=MergeSort(lists[0:div]) right=MergeSort(lists[div:]) return Merge(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
    def AjustHeap(lists,i,size):
            min=i
            left=2*i+1
            right=2*i+2
            if i < size/2:
                    if right < size and lists[min] > lists[right]:
                            min=right
                    if left < size and lists[min]>lists[left]:
                            min=left
                    if min!=i:
                            lists[i],lists[min]=lists[min],lists[i]
                            AjustHeap(lists,min,size)
    def BuildHeap(lists,size):
            for i in range(0,(size/2))[::-1]:
                    AjustHeap(lists,i,size)
    def HeapSort(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)
            return lists
    arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]
    print HeapSort(arr)

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

    #!user/bin/python
    def ShellSort(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
            return lists
    arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]
    print ShellSort(arr)

    8.计数排序:

  • 相关阅读:
    最短路径-Dijkstra算法(转载)
    递归算法到非递归算法的转换
    向量点乘(内积)和叉乘(外积、向量积)概念及几何意义(转载)
    数据预处理之独热编码(One-Hot Encoding)(转载)
    MyEclipse中手工添加dtd支持
    怎样sublime显示文件夹
    sublime_Text3中snippet设置信息头(包括作者、日期)
    解决Sublime_Text不能安装插件的方法
    Python设置默认编码为UTF-8
    解决火狐启动缓慢的方法
  • 原文地址:https://www.cnblogs.com/students/p/8699657.html
Copyright © 2020-2023  润新知