八种经典排序算法（python实现）

0、算法概述

1、冒泡排序

2、插入排序

0、算法概述

0.1 算法分类

十种常见排序算法可以分为两大类：

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。

非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

0.2 算法复杂度

0.3 相关概念

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
空间复杂度：是指算法在计算机

内执行时所需存储空间的度量，它也是数据规模n的函数。

1、冒泡排序

'''
冒泡排序法实现升序
1.算法思想：遍历列表n-1次，每次遍历比较相邻的两个元素的大小，如果前一个元素比后一个元素大，则交换其位置
2.时间复杂度：最坏o(n^2),最优o(n)
3.空间复杂度：o(1)
4.稳定性：稳定
'''

1.1 算法描述

比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。

1.2 动图演示

1.3 代码实现

def Bubble_Sort(li):
    n = len(li)
    for i in range(n-1):
        for j in range(n-i-1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
 
li = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
Bubble_Sort(li)
print(li)

2、插入排序

'''
插入排序实现升序
1.算法思想：遍历一次列表，通过构建有序序列，将未排序的数据，在已经排序的序列中从后向前扫描，找到相应的位置并插入
2.时间复杂度：最坏o(n^2)，最优o(n)
3.空间复杂度：o(1)
4.稳定性：稳定
'''

2.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

2.2 动图演示

2.2 代码实现

 
def Insertion_Sort(li):
    n = len(li)
    for i in range(1, n):
        for j in range(i, 0, -1):
            if li[j] < li[j-1]:
                li[j], li[j-1] = li[j-1], li[j]
 
li = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
Insertion_Sort(li)
print(li)

3、选择排序

'''
选择排序实现升序
1.算法思想：遍历列表n-1次，每遍历一次选出最小的元素，并把它存放在列表的起始位置从列表的第一个元素为基准开始，将列表中剩下的所有元素与其进行对比，遇到比其小的元素，与其交换位置，遍历完成选出最小的；然后将列表的第二个元素作为基准依次下去。。
2.时间复杂度：最优o(n^2)最坏o(n^2)
3.空间复杂度：o(1)
4.稳定性：不稳定
例如：li = [(26,2), 16, 17, 15, (26,1), 11, 9],
(26,2)会到(26,1)的后面
'''

3.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

3.2 动图演示

3.3 代码实现

def Selection_Sort(li):
    n = len(li)
    for i in range(n-1):
        for j in range(i+1, n):
            if li[j] < li[i]:
                li[j], li[i] = li[i], li[j]
 
li = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
Selection_Sort(li)
print(li)

4、快速排序

'''
快排实现升序：
1.算法思想：首先选出一个基准，通过一趟排序，将序列分为两个部分，一部分是比这个基准小的，另一部分是比这个基准大的，然后按照此方法依次递归。
2.时间复杂度：o(nlogn)
3.空间复杂度：o(logn)
4.稳定性：不稳定
'''

4.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

4.2 动图演示

4.3 代码实现

def Quick_Sort(li, start, end):
    if start >= end:
        return
 
    low = start
    high = end
    mid = li[start]
 
    while low < high:
        '''
        这个循环中为什么还要有low < high的条件，是因为，在这个循环中
        high的值在不断的改变，而外层循环比较的始终是最开始进入外层循环
        时的low和high
        '''
        while low < high and li[high] > mid:
            high = high - 1
        li[low] = li[high]
 
        while low < high and li[low] < mid:
            low = low + 1
        li[high] = li[low]
 
    li[low] = mid
 
    Quick_Sort(li, start, low)
    Quick_Sort(li, low+1, end)
 
li = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
Quick_Sort(li, 0 ,len(li)-1)
print(li)

5、希尔排序

'''
希尔排序实现升序：
1.算法描述：希尔排序是插入排序的一种，将数组中的元素按照一定的增量分成多组，放在一个表中，并对表的列进行插入排序，然后主次减少增量，直到增量为1，完成排序
2.时间内复杂度：o(n^2)
3.空间复杂度：o(1)
4.稳定性：不稳定
'''

1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

5.1 算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

5.2 动图演示

5.3 代码实现

 
def Shell_Sort(li):
    n = len(li)
    step = int(n/2)
    while step > 0:
        for i in range(step, n):
            j = i
            while  j >= step and li[j-step] > li[j]:
                li[j-step], li[j] = li[j], li[j-step]
                '''
                为什么是j -= step:
                当j-step < step时，相对应的位置的元素比较完毕
                '''
                j -= step
        step = int(step / 2)
 
li = [84, 83, 88, 87, 61, 50, 70, 60, 80, 99]
Shell_Sort(li)
print(li)

6、归并排序

 
'''

归并排序实现升序：

1.算法思想：采用分治法，先递归分解数组，将数组分解成最小之后，然后再递归合并数组，

基本思路就是比较两个数组的最前面的数，谁小就先去谁，去了之后相应的指针

就往后移一位，直到数组为空。

2.时间复杂度：o(nlogn)

3.空间复杂度：o(n)

4.稳定性：稳定

'''

6.1 算法描述

把长度为n的输入序列分成两个长度为n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。

6.2 动图演示

6.3 代码实现

def merge_sort(li):
    if len(li) <= 1:
        return li
 
    #二分分解
    num = int(len(li)/2)
    left = merge_sort(li[:num])
    right = merge_sort(li[num:])
 
    #合并
    return merge(left, right)
 
 
def merge(left, right):
    '''合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组'''
    #left和right的下标指针
    l, r = 0, 0
    result = []
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
 
        result += left[l:]
        result += right[r:]
        return result
 
li = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
sort_li = merge_sort(li)
print(sort_li)

6.4 算法分析

归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。

7、计数排序

'''
计数排序实现升序：
1.算法思想：计数排序不是基于比较的排序算法，其核心是将输入的数据值转化为键值存储在额外开辟的数组空间中。作为一种相信那个时间内复杂度的排序，计数排序要求输入的数据必须是在有确定范围的整数。
2.时间复杂度：o(n)
3.空间复杂度：o(n)
4.稳定性：稳定
'''

7.1 算法描述

找出待排序的数组中最大和最小的元素；
统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

7.2 动图演示

7.3 代码实现

def countingSort(li):
    n = len(li)
    #定义一个有n个元素的空列表
    res = [None] * n
 
    #遍历数组，对比数组中的每一个元素比当前元素小的个数，和与当前元素相同的个数
    for i in range(n):
        p = 0
        q = 0
        for j in range(n):
            if li[i] > li[j]:
                p += 1
            elif li[i] == li[j]:
                q += 1
        
        #将元素放到合适的位置，统计的数为index,index对应的元素为该元素
        for k in range(p, p+q):
            res[k] = li[i]
    return res
 
li = [2, 3, 8, 7, 1, 2, 2, 2, 7,3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2]
result = countingSort(li)
print(result)

7.4 算法分析

计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。

8、桶排序

'''
桶排序实现升序：
1.算法思想：将数组分到有限量的桶里，每个桶再分别排序（有可能使用别的算法进行排序）
2.时间复杂度：最差o(n^2)，最优o(n+k)
3.空间复杂度：o(n*k)
4.稳定性：稳定
'''

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

8.1 算法描述

设置一个定量的数组当作空桶；
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序；
从不是空的桶里把排好序的数据拼接起来。

8.2 代码实现

def bucker_sort(li, n):
    #1.创建n个空桶
    new_list = [[] for k in range(n)]
 
    #2.把array[i]插入到bucket[n*array[i]]
    for data in li:
        '''
        注意：对于全部都是小数的序列，可以采用*，将在不同范围中的数放在不同
             桶中
        '''
        num = int(data / n)
        new_list[num].append(data)
 
    #3.桶内排序
    for i in range(n):
        new_list[i].sort()
 
 
    #4.生成新排序后的列表（可以用新的列表保存，也可以直接在原列表上进行操作）
    index = 0
    #new_li = []
    for i in range(n):
        if new_list[i] != []:
            for j in range(len(new_list[i])):
                #new_li.append(mnew_list[i][j])
                li[index] = new_list[i][j]
                index += 1
    return  li
 
 
 
def main():
    array = [5, 4, 3, 8, 7, 4, 5]
    n = len(array)
    print(bucker_sort(array, n))
 
 
if __name__=='__main__':
    main()

8.3 算法分析

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

联系我们，一起学Python吧

微信群（关注「Python家庭」每周福利惊喜大狂欢，一起轻松学Python吧）