八种排序算法总结和python实现（插入、希尔、选择、堆、冒泡、快排、归并、基数）

排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。内排序有可以分为以下几类：

(1)、插入排序：直接插入排序、二分法插入排序、希尔排序。

(2)、选择排序：简单选择排序、堆排序。

(3)、交换排序：冒泡排序、快速排序。

(4)、归并排序

(5)、线性时间排序：计数排序、基数排序、桶排序

堆排序 、 快速排序 、 希尔排序 、 直接选择排序 不是稳定的排序算法，而 基数排序 、 冒泡排序 、 直接插入排序 、 折半插入排序 、 归并排序 是稳定的排序算法

注：快排和归并排序的时间复杂度写反了，快排是O(1),归并是O(nlogn)

1、插入排序

O(n2) O(1) 稳定

插入排序是基于比较的排序。所谓的基于比较，就是通过比较数组中的元素，看谁大谁小，根据结果来调整元素的位置。

因此，对于这类排序，就有两种基本的操作：①比较操作； ②交换操作

def insertSort(num):

    for i in range(1,len(num)):

        t = num[i]

        k = i

        for j in reversed(range(i)):

            if t<num[j]:

                num[k] = num[j]

                num[j] = t

                k = j

2、希尔排序

不稳定， 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

def shellSort(num):

    length = len(num)

    gap = len(num)//2

    while gap>0:

        for i in range(gap,length):

            j = i

            while j-gap>=0 and num[j]<num[j-gap]:

                t = num[j]

                num[j] = num[j-gap]

                num[j-gap] = t

                j -=gap         

        gap = gap//2

3、选择排序

O(n2) O(1)  不稳定

它的工作原理是每一次从待排序的元素 中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

def mySort(num):

    for i in range(len(num)):

        temp = num[i]

        k = i

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

            if num[j]<temp:

                temp = num[j]

                k = j

        num[k] = num[i]

        num[i] = temp

4、堆排序

O(nlogn) O(1),不稳定

堆排序(Heapsort)是指利用堆积树（堆）实现的 ，它是选择排序的一种。可以利用数组 的特点快速定位指定索引的元素

def adjust(arr,i,length):

    while i*2+1<length:

        n = i*2+1

        if n+1<length:

            if arr[n+1]>arr[n]:

                n = n+1

        if arr[n]>arr[i]:

            t = arr[n]

            arr[n] = arr[i]

            arr[i] = t

            i = n

        else:

            break

def myHeapSort(num):

    length = len(num)

    k = (length-1)//2

    for i in reversed(range(k+1)):

        adjust(num,i,length)

    while length>0:

        t = num[0]

        num[0] = num[length-1]

        num[length-1] = t

        length-=1

        adjust(num,0,length)

5、冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

def popSort(num):

    for i in reversed(range(len(num))):

        for j in range(i+1):

            if num[i]<num[j]:

                t = num[i]

                num[i] = num[j]

                num[j] = t

6、快排

不稳定

利用分治法， 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序

def quickSort(num,i,j):

    if i>=j:

        return

    k = num[i]

    start = i

    end = j

    while i < j:

        while i<j and num[j]>k:

            j-=1

        num[i] = num[j]

        while i<j and num[i]<k:

            i+=1

        num[j] = num[i]

    num[i] = k

    quickSort(num,start,i-1)

    quickSort(num,j+1,end)

7、归并

归并是O(nlogn)时间复杂度中稳定的排序。

def mergeSort(num,i,j):

    if i==j:

        return [num[i]]

    m = (i+j)//2

    l = mergeSort(num,i,m)

    r = mergeSort(num,m+1,j)

    res = []

    i = 0

    j = 0

    while i<len(l) and j<len(r):

        if l[i]<r[j]:

            res.append(l[i])

            i+=1

        else:

            res.append(r[j])

            j+=1

    while i<len(l):

        res.append(l[i])

        i+=1

    while j<len(r):

        res.append(r[j])

        j+=1

    return res

8、基数排序

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。

整个算法过程描述如下：

1、将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。

2、从最低位开始，依次进行一次排序。

3、这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

基数排序的时间复杂度是 O(k•n)，其中n是排序元素个数，k是数字位数。

排序是稳定的。

def baseSort(num):

    m = 0

    for n in num:

        i = 10

        cnt = 1

        while n//i!=0:

            i*=10

            cnt+=1

        m = max(m,cnt)

    for i in range(0,m):

        d = pow(10,i)

        a = [[] for _ in range(10)]

        for n in num:

            k = n//d%(10)

            a[k].append(n)

        res = []

        for n in a:

            res = res + n

        num = res

    return num