排序算法的python实现

一、冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

冒泡排序的python代码实现（方法一）：

def bubble_sort(list):
    for i in range(len(list)):#控制需要进行所少趟
        flag = True
        for j in range(len(list) - 1 - i):  #每趟需要比较多少次
            if list[j] > list[j + 1]:
                temp = list[j]
                list[j] = list[j + 1]
                list[j + 1] = temp
                flag = False
        if flag:
            break
    return list

冒泡排序的python代码实现（方法二）：

def bubble(bubbleList):
    listLength = len(bubbleList)
    while listLength > 0:
        for i in range(listLength - 1):
            if bubbleList[i] > bubbleList[i + 1]:
                temp = bubbleList[i]
                bubbleList[i] = bubbleList[i + 1]
                bubbleList[i + 1] = temp
        listLength -= 1
    print(bubbleList)

二、选择排序

算法步骤:首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置;再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾;重复第二步，直到所有元素均排序完毕。

选择排序的python代码实现：

def selection_sort(list):
    for i in range(len(list)-1):
        min_ = i #记录最小索引
        for j in range(i+1, len(list)):
            if list[j] < list[min_]:
                min_ = j
        list[i], list[min_] = list[min_], list[i]
    return list

三、插入排序

有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，
但要求插入后此数据序列仍然有序。插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

插入排序的python代码实现（方法一）：

def insertion_sort(list):
    for i in range(len(list)):
        pre_= i - 1
        current = list[i]
        while pre_ >= 0 and list[pre_] > current:
            list[pre_ + 1] = list[pre_]
            pre_-= 1
        list[pre_ + 1] = current
    print(list)

if __name__ == '__main__':
    list = [3, 4, 1, 2, 5, 8, 0]
    insertion_sort(list)

插入排序的python代码实现（方法二）：

import random
n = 1000
Length =8
list = random.sample(range(n), Length)  #在指定序列中随机获取指定长度片段
print('before sort:', list)
for i in range(1, Length):   #默认第一个元素已经在有序序列中，从后面元素开始插入
    for j in range(i, 0, -1):    #逆向遍历比较，交换位置实现插入
        if list[j] < list[j - 1]:
            list[j], list[j - 1] = list[j - 1], list[j]
print('after sort:', list)

四、希尔排序

比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。

希尔排序的python代码实现：

def shell_sort(list):
    n = len(list)
    h = 1
    while h < n / 3:
        h = 3 * h + 1
    while h >= 1:
        for i in range(h, n):
            j = i
            while j >= h and list[j] < list[j - h]:
                list[j], list[j - h] = list[j - h], list[j]
                j -= h
        h = h // 3
    return list

if __name__ == '__main__':
    list = [1, 18, 21, 78, 9, 17, 8, 6, 19, 35, 3, 2]
    shell_sort(list)

五、归并排序

归并排序的python代码实现：

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)
def merge(left, right):
    l, r = 0, 0
    result = []
    while l < len(left) and r < len(right):
        if left[l] <= right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += list(left[l:])
    result += list(right[r:])
    return result


if __name__ == '__main__':
    lists = [1, 18, 21, 78, 9, 17, 8, 6, 19, 35, 3, 2]
    print(merge_sort(lists))

六、快速排序

快速排序的python代码实现：

def quick_sort(data):
    """快速排序"""
    if len(data) >= 2:  # 递归入口及出口
        mid = data[len(data) // 2]  # 选取基准值，也可以选取第一个或最后一个元素
        left, right = [], []  # 定义基准值左右两侧的列表
        data.remove(mid)  # 从原始数组中移除基准值
        for num in data:
            if num >= mid:
                right.append(num)
            else:
                left.append(num)
        return quick_sort(left) + [mid] + quick_sort(right)
    else:
        return data

堆排序

堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

origin = [0, 80, 30, 50, 90, 70, 20, 10, 40, 60]  # 0不算，只是占位
length = len(origin) - 1

def heap_adjust(n, i, array: list):
    # i = n // 2
    while n >= 2 * i:
        max_child_index = 2 * i
        right_child_index = 2 * i + 1
        if right_child_index <= n and array[right_child_index] > array[max_child_index]:
            max_child_index  = right_child_index
        if array[max_child_index] > array[i]:
            array[i], array[max_child_index] = array[max_child_index], array[i]
            i = max_child_index
        else:
            break
    return array


def heap(n, array: list):
    start = n // 2  # 从最后一个有子节点的根节点开始调整
    for i in range(start, 0, -1):
        heap_adjust(n, i, array)  # 就地修改
    return array


heap(length, origin)
print(origin)


def sort(n, array: list):
    while n > 1:
        array[1], array[n] = array[n], array[1]
        n -= 1
        heap_adjust(n, 1, array)
    return array

sort(length, origin)
print(origin[1:])