回顾经典排序算法Python实现

常见的八大排序算法，如下图：

排序算法的性能比较

各排序算法的思想与Python实现

1.直接插入排序

核心思想：

将数组中的所有元素依次跟其序列前面已排好序的元素比较（从后往前遍历），若选择的元素比已排好序的元素小，则相互交换次序

代码实现：

def insert_sort(list):
    length = len(list)
    for i in range(1,length):
        key = list[i]
        j = i - 1
        while j >= 0:
            if key < list[j]:
                list[j + 1] = list[j]
                list[j] = key
            j -= 1
    return list

2.希尔排序

核心思想：

希尔排序又称递减增量排序算法，利用插入排序对几乎已经排好序的序列操作时效率很高，几乎可以打到线性排序效率的特点，对插入排序的优化。

希尔排序通过“步长”来控制比较大小的数据之间的距离，在开始的阶段使用较大步长可以将一个元素向最终位置前进一大步，然后再用较小步长进行精确调整。算法最后一步就是普通的插入排序，到了这一步，序列几乎是已经排序好的，效率会很高。

代码实现：

def shell_sort(list):
    length = len(list)
    gap = length / 2
    while gap > 0:
        for i in range(gap,length):
            temp = list[i]
            j = i - gap
            while j >= 0:
                if temp < list[j]:
                    list[j + gap] = list[j]
                    list[j] = temp
                j -= gap        
        gap = gap / 2
    return list

3.冒泡排序

核心思想：

比较相邻的两个元素，如果前面的元素大于后面的元素，则交换位置。从头开始到尾，依次比较相邻的元素，一轮下来最大的元素会置于末尾。重复以上轮回，直到又一轮没有交换元素则排序结束。

代码实现：

def bubble_sort(list):
    length = len(list)
    for i in range(length):
        flag = True
        for j in range(0,length - j - 1):
            if list[j] > list[j + 1]:
                list[j + 1],list[j] = list[j],list[j + 1]
                flag = False
        if flag:
            return list
    return list

4.快速排序

核心思想：

从数列中选取一个元素作为基准（最左，最右，中间），从头尾开始扫描，将比基准小的置于左边，比基准大的置于右边。按照以上规则，递归选取基准排序。

代码实现：
 

def quick_sort(list,left,right):
    if left >= right:
        return list
    key = list[left]
    low = left
    high = right
    while left < right:
        while list[right] >= key and left < right:
            right -= 1
        list[left] = list[right]
        while list[left] <= key and left < right:
            left += 1
        list[right] = list[left]
    list[right] = key
    quick_sort(list,low,left - 1)
    quick_sort(list,left + 1,high)
    return list

5.直接选择排序

核心思想：

（从大到小排序）从数列中遍历找到最小的元素置于起始位置，依次从剩余数列中找到最小的元素置于已排数据的末尾

代码实现：

def select_sort(list):
    length = len(list)
    for i in range(length):
        min = i
        for j in range(i+1,length):
            if list[min] > list[j]:
                min = j
        temp = list[min]
        list[min] = list[i]
        list[i] = temp
    return list

6.堆排序

核心思想：

堆是一颗完全二叉树，其父节点的元素总是小于（或者大于）左右子节点的元素值

代码实现：

def adjust_heap(list,i,length):
    lchild = 2*i+1
    rchild = 2*i+2
    max = i
    if i < length/2:
        if lchild < length and list[lchild] > list[max]:
            max = lchild
        if rchild < length and list[rchild] > list[max]:
            max = rchild
        if max != i:
            list[max],list[i] = list[i],list[max]
            adjust_heap(list,max,length)

def build_heap(list,length):
    for i in range(0,(length/2))[::-1]:
        adjust_heap(list,i,length)

def heap_sort(list):
    length = len(list)
    build_heap(list,length)
    for i in range(0,length)[::-1]:
        list[0],list[i] = list[i],list[0]
        adjust_heap(list,0,i)

7.归并排序

核心思想：

该算法采用分治法思想，先给子序列排序，再合并子序列得到完全的排序数列

假设序列有n个元素，从头开始将相邻两个元素归并并排序，得到n/2个序列；再将相邻的序列归并排序得到n/4个序列，如此反复直至所有元素归并排序完毕。

代码实现：

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(list):
    if len(list) <= 1:
        return list
    num = len(list)/2
    left = merge_sort(list[:num])
    right = merge_sort(list[num:])
    return merge(left,right)

8.基数排序

核心思想：

对数列中的数从最低位开始，每次取一位开始比较，依次取个位、十位，再对位对元素进行排序

代码实现：