排序算法

排序算法（英语：Sorting algorithm）是一种能将一串数据依照特定顺序进行排列的一种算法。

现在我来介绍下最经典的冒泡排序算法

冒泡排序

冒泡排序算法的运作如下：
1.比较相邻的元素。如果第一个比第二个大（升序），就交换 他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

# -*- coding: utf-8 -*-def bubble_sort(alist):    n = len(alist)    for j in range(n - 1):        count = 0        for i in range(n - j - 1):            if alist[i] > alist[i + 1]:                alist[i], alist[i + 1] = alist[i + 1], alist[i]        if 0 == count:            breakif __name__ == '__main__':    li = [22, 10, 77, 44, 55, 33]    print(li)    bubble_sort(li)    print(li)

时间复杂度
最优时间复杂度：O(n) （表示遍历一次发现没有任何可以交换的元素，排序结束。）
最坏时间复杂度：O(n^2)
稳定性：稳定

选择排序

它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

#-*- coding: utf-8 -*-def select_sort(alist):    n = len(alist)    for j in range(n-1):        min_index = j        for i in range(j+1, n):            if alist[i] < alist[min_index]:                min_index = i        if j != min_index:            alist[j], alist[min_index] = alist[min_index], alist[j]if __name__ == '__main__':    li = [22, 10, 77, 44, 55, 3]    select_sort(li)    print(li)

时间复杂度
最优时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
稳定性：不稳定（考虑升序每次选择最大的情况）

插入排序

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

# -*- coding: utf-8 -*-def insert_sort(alist):    n = len(alist)    for i in range(1, n):        for j in range(i, 0, -1):            if alist[j] < alist[j - 1]:                alist[j], alist[j - 1] = alist[j - 1], alist[j]            else:                breakif __name__ == '__main__':    li = [22, 10, 77, 44, 55, 3]    insert_sort(li)    print(li)

时间复杂度
最优时间复杂度：O(n) （升序排列，序列已经处于升序状态）
最坏时间复杂度：O(n^2)
稳定性：稳定

希尔排序

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

# -*- coding: utf-8 -*-def shell_sort(alist):    n = len(alist)    gap = n // 2    while gap >= 1:        for j in range(gap, n):            i = j            while (i - gap) >= 0:                if alist[i] < alist[i - gap]:                    alist[i], alist[i - gap] = alist[i - gap], alist[i]                    i -= gap                else:                    break        gap //= 2if __name__ == '__main__':    li = [22, 10, 77, 44, 55, 3]    shell_sort(li)    print(li)

时间复杂度
最优时间复杂度：根据步长序列的不同而不同
最坏时间复杂度：O(n^2)
稳定性：不稳定

快速排序

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

# -*- coding: utf-8 -*-def quick_sort(alist, start, end):    # 递归的退出条件    if start >= end:        return    # 设定起始元素为要寻找位置的基准元素    mid = alist[start]    # left为序列左边的由左向右移动的游标    left = start    # right为序列右边的由右向左移动的游标    right = end    while left < right:        # 如果left与right未重合，right指向的元素不比基准元素小，则right向左移动        while left < right and alist[right] >= mid:            right -= 1        # 将right指向的元素放到left的位置上        alist[left] = alist[right]        # 如果left与right未重合，left指向的元素比基准元素小，则left向右移动        while left < right and alist[left] < mid:            left += 1        # 将left指向的元素放到right的位置上        alist[right] = alist[left]    # 退出循环后，left与right重合，此时所指位置为基准元素的正确位置    # 将基准元素放到该位置    alist[left] = mid    # 对基准元素左边的子序列进行快速排序    quick_sort(alist, start, left - 1)    # 对基准元素右边的子序列进行快速排序    quick_sort(alist, left + 1, end)if __name__ == '__main__':    li = [22, 10, 77, 44, 55, 3]    quick_sort(li, 0, len(li) - 1)    print(li)

时间复杂度
最优时间复杂度：O(nlogn)
最坏时间复杂度：O(n^2)
稳定性：不稳定