排序算法总结

最新推荐文章于 2025-09-07 20:32:33 发布

转载最新推荐文章于 2025-09-07 20:32:33 发布 · 51 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/wanwanmom/p/9622627.html

文章标签：

#数据结构与算法

时间复杂度

0(1)<0(logn)<0(n)<0(nlogn)<o(n²)<...<0(n!)

冒泡排序

算法：在数组x[n]中，从第一个数开始，拿x[i]和x[i+1]比较，如果x[i]>x[i+1]，交换两个数，这样遍历一遍数组后，最大的元素排在了最后面；然后第二次比较剩下的n-1个数；直到完成所有的排序，由于每次都是把最大的排在最后面，称为冒泡排序。

def bubble_sort(mylist):
    for i in range(len(mylist)):
        for j in range(len(mylist)-1-i):
            if mylist[j]<mylist[j+1]:
                mylist[j],mylist[j+1]=mylist[j+1],mylist[j]
    print (mylist)

bubble_sort([1,43,2,42,3443])

插入排序

第一次从第2个元素开始排序，key=x[2]，与x[1]比较；第二次从第3个元素开始排序，先与x[2]比较，最差还要与x[1]比较。。。。。

def insert_sort(mylist):
    for i in range(1,len(mylist)):
        key = mylist[i]
        j = i-1
        while j >= 0:
            if mylist[j] > key:
                mylist[j],mylist[j+1] = mylist[j+1],mylist[j]
                key = mylist[j]
                j -= 1
            else:
                break
    print (mylist)

insert_sort([88,25,93,54,17,9])

选择排序

算法：设置min=x[1]，比较min和每1个元素，找到最小值后，交换min和该值，比较冒泡排序，找到最小值的索引，只交换1次。

def selectSort(mylist):
    for i in range(len(mylist)):
        min = i
        for j in range(i+1,len(mylist)):
            if mylist[min] > mylist[j]:
                min = j
        mylist[i],mylist[min] = mylist[min],mylist[i]

    print (mylist)

selectSort([33,4,76,21,9,1])

快速排序

选择一个基数flag，其他每一个元素都和基数比较，小于基数的放基数左边，大于基数的放基数右边，然后再对基数左、右边序列做递归排序，直到序列只有1个数。

定义flag为x[n-1]，i=-1，j=0；循环：比较x[j]与flag，当x[j]>flag，j+1，pass；当x[j]<flag，i=i+1，j+1，交换x[i]和x[j]。

def quickSort(mylist):
    def pathSort(lista,startIndex,endIndex):
        flag = lista[endIndex]
        i = startIndex - 1
        for j in range(startIndex,endIndex):
            if lista[j] > flag:
                pass
            else:
                i += 1
                lista[i],lista[j] = lista[j],lista[i]
        lista[i+1],lista[endIndex] = lista[endIndex],lista[i+1]
        return i+1

    def qSort(listb,startIndex,endIndex):
        if startIndex >= endIndex:
            return
        middle = pathSort(listb,startIndex,endIndex)
        qSort(listb,startIndex,middle-1)
        qSort(listb,middle+1,endIndex)
        return  listb

    print (qSort(mylist,0,len(mylist)-1))

quickSort([33,1,56,3,22,7,82])

二叉树

（1）基础知识
【二叉树】:二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。
【满二叉树】:高度为N的满二叉树有2^N- 1个节点的二叉树。
【完全二叉树】: 若设二叉树的深度为h，除第h 层外，其它各层(1～h-1) 的结点数都达到最大个数，第h 层所有的结点都连续集中在最左边，这就是完全二叉树。

先序遍历二叉树：根节点-左子树-右子树；

时间复杂度

排序法	最差时间分析	平均时间复杂度	稳定度	空间复杂度
冒泡排序	O(n²)	O(n²)	稳定	O(1)
快速排序	O(n²)	O(n*log₂n)	不稳定	O(log₂n)~O(n)
选择排序	O(n²)	O(n²)	稳定	O(1)
二叉树排序	O(n²)	O(n*log₂n)	不一顶	O(n)
插入排序	O(n²)	O(n²)	稳定	O(1)
堆排序	O(n*log₂n)	O(n*log₂n)	不稳定	O(1)
希尔排序	O	O	不稳定	O(1)