排序算法

排序算法（英语：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:
            break


if __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:
                break


if __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 //= 2


if __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)
稳定性：不稳定