常用排序算法的Python实现

冒泡排序

算法思想：

对于一组需要排序的数据，对于相邻的两个数进行比较，使较大（或者较小）的数一直向后推，经过多层排序之后，使整个序列是有序的。

算法实现：

def bubble_sort(L):
    length = len(L)
    if length == 0 or length == 1:
        return L
    for i in range(length):
        for j in range(length-i-1):
            if L[j] > L[j+1]:
                temp = L[j]
                L[j] = L[j+1]
                L[j+1] = temp
    return L

print(bubble_sort(data))

算法的实现使用了两层for循环，其中对于外层for循环来说，第一次for循环，最大的数被推到最后面，第二次for循环，次大的数被推到次后面...依次类推，而内层for循环的作用就是实现将当前层次的最大数找出来，向后沉。

复杂度：

• 时间复杂度
  
  平均情况O(n^2)， 最好情况O(n)， 最坏情况O(n^2)
• 空间复杂度
  
  O(1)
• 稳定性
  
  不稳定

快速排序

算法思想：

任意设置一个基准元素，一般是第一个或者最后一个，将序列以该基准元素为基准，分割成比他小的一部分和比他大的一部分，此时，该基准元素所在的位置就是排序终了之后的准确位置，在对左右两边的序列继续执行同样的操作，直整个个序列有序。

算法实现：

def quick_sort(lists, left, right):
    if left >= right:
        return lists
    key = lists[left]     # 用作基准
    low = left
    high = right
    while left < right:
        while left < right and lists[right] >= key:
            right -= 1
        lists[left] = lists[right]
        while left < right and lists[left] <= key:
            left += 1
        lists[right] = lists[left]

    lists[right] = key
    quick_sort(lists, low, left - 1)
    quick_sort(lists, left + 1, high)
    return lists

print(quick_sort(data, 0, len(data)-1))

内层的while循环中，以key为基准，从序列的右边找出比key值小的元素，放在key的左边去，再从key的左边找出比key值大的元素，放在key的右边，此时正好填补了放到左边的的那个空位，多次循环，直到序列有序。

复杂度：

• 时间复杂度
  
  平均情况O(nlog2n)， 最好情况O(nlog2n)， 最坏情况O(n^2)
• 空间复杂度
  
  O(nlog2n)
• 稳定性
  
  不稳定

选择排序

算法思想：

在需要排序的一组数中，选出最小（或者最大）的一个数与第一个位置的数交换，然后在剩下的数中在找到最小（或者最大）的数与第二个位置的数交换，一次类推，直到倒数第二个数与倒数第一个数交换完成为止。

算法实现：

def select_sort(L):
    length = len(L)
    if length == 0 or length == 1:
        return L

    def _min(s):
    '''
    实现从后面的值中找到最小值的索引
    '''
        min = s
        for i in range(s, length):
            if L[i] < L[min]:
                min = i
        return min

    for i in range(length):
        min = _min(i)
        if i != min:
            temp = L[min]
            L[min] = L[i]
            L[i] = temp
    return L

print(select_sort(data))

每一次循环，都将该次循环的i作为基准，从i后面的数中通过_min()函数来找到后面数据最小值的索引，在for循环的循环体内交换位置，目的是将小值放到前面去。这样，每一次循环，数中最前面的一部分数据是从小到大排序的，直到最后，所有的数据都是有序的为止。

复杂度：

• 时间复杂度
  
  平均情况O(n^2)， 最好情况O(n^2)， 最坏情况O(n^2)
• 空间复杂度
  
  O(1)
• 稳定性
  
  不稳定

归并排序

算法思想：

主题思想是将两个有序表河滨更成为一个新的有序表，将待排序序列分位若干个子序列，每个子序列是有序的，然后在将其合并为一个整体，使用递归的思想。

算法实现：

def merge(left, right):
    i, j = 0, 0
    result = []
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result

def merge_sort(lists):
    # 归并排序
    if len(lists) <= 1:
        return lists
    num = int(len(lists) / 2)
    left = merge_sort(lists[:num])
    right = merge_sort(lists[num:])
    return merge(left, right)

print(merge_sort(data))

将一个序列一直对半拆分，分为若干个子序列，直到该子序列只有一个元素为止，然后将其合并。因此主要的问题就变成了如何将两个有序序列合并，这里新建一个空序列，遍历比较两个序列，将较小的元素放在新的序列中，直到某一个序列为空，此时很可能另外的一个序列非空，因此需要将剩余的已经有序的元素一次性添加到新建的序列中。

复杂度：

• 时间复杂度
  
  平均情况O(nlog2n)， 最好情况O(nlog2n)， 最坏情况O(nlog2n)
• 空间复杂度
  
  O(n)
• 稳定性
  
  稳定

插入排序

算法思想：

将序列的第一个元素当做已经排序好的序列，然后从后面的第二个元素开始，逐个元素进行插入，直到整个序列有序为止。

算法实现：

def insert_sort(L):

    length = len(L)
    if length==0 or length==1:
        return L
    for i in range(1,length):
        value = L[i]
        j = i-1
        while j>=0 and L[j]>value:
            L[j+1] = L[j]
            j-=1
        L[j+1] = value
    return L

print(insert_sort(data))

对于for循环来说，第一次循环结束，整个序列的第一个元素是有序的，第二次循环，前面两个元素是有序的，第三次for循环，前面三个元素是有序的...对于while循环来说，只要索引为i的前面某个元素比我们设置的“哨兵”value的值大，就把它放在后面去，直到前面所有的元素均比value小，这时候本次排序结束，本次排序的结果依然是有序的，因为上一次的结果是有序的，我们本次排序只是将一个新的值加入进去，并没有破坏之前的结构，因此将其称之为“插入排序”。

复杂度：

• 时间复杂度
  
  平均情况O(n^2)， 最好情况O(n)， 最坏情况O(n^2)
• 空间复杂度
  
  O(1)
• 稳定性
  
  稳定

希尔排序

算法思想：

希尔排序是对直接插入排序的改进版本，又称为缩小增量排序，将整个序列分割成若干个子序列，分别进行直接插入排序，待各个子序列基本语序后，在对全体进行直接插入排序。

算法实现：

def shell_sort(lists):
    count=len(lists)
    step=2
    group=int(count/step)
    while group>0:
        for i in range(group):
            j=i+group
            while j<count:
                key=lists[j]
                k=j-group
                while k>=0:
                    if lists[k]>key:
                        lists[k+group]=lists[k]
                        lists[k]=key
                    k=k-group
                j=j+group
        group=int(group/step)
    return lists
print(shell_sort(data))