用python完成排序算法

排序算法总结

冒泡排序

相邻两个元素，两两循环比较，每趟筛选出一个最大或者最小的元素（有序区在后面）

def bubble_sort(data):
    # 第一层循环：循环一次，代表一趟，并筛选出一个最大或最小元素
    for i in range(len(data)-1):
        temp = True
        # 第二层循环：循环一次，表示相邻两个元素进行了一次比较
        for j in range(len(data)-1-i):
            if data[j] > data[j+1]:
                # 相邻两个元素进行替换
                data[j], data[j+1] = data[j+1], data[j]
         		temp = False
        if temp:
            return

选择排序

将一个元素设为初始值（一般都是第一个值），循环后面每个元素与第一个元素比较，最终筛选出一个最小或最大值（有序区在前面）

def select_sort(data):
    # 第一层循环：取出数组中的每个元素
    for i in range(len(data)):
        temp = i   # 拿取一个元素用来比较
        # 第二层循环：从第i后面的一个值开始循环，与data[i]进行比较
        for j in range(i+1,len(data)):
            if data[j] < data[temp]:
                data[temp], data[j] = data[j], data[temp]             

插入排序

将第一个元素作为有序区的元素，从无序区取出一个元素与有序区元素进行逐个比较，并加入到有序区，依次循环

def insert_sort(data):
    # 第一层循环： 从第二个元素开始循环取出元素，与有序区元素进行比较
    for i in range(1,len(data)):
        temp = data[i]
        j = i-1
        while j>=0 and temp < data[j]:   
            data[j+1] = data[j]    # i = j+1
            j = j-1    # 在与前面一个元素进行比较，所以j需要减1
        # 当j = -1 就跳出循环，将temp值赋给第一个值，即data[0]
        data[j+1] = temp

快速排序

取第一个元素p，使元素p归位（需要建立归位函数）；

列表（数组）被P分成两部分，左边都比P小，右边都比P大；

递归完成排序。

总结就分成两部分：整理 + 递归

# 归位函数，定位中间值P
def partition(data,left,right):
    temp = data[left]
    while left < right:
        # 如果最右边的值大于中间值，则最右边值往后退一个位置，反之，就将值赋值给最左边位置
        while left < right and data[right] >= temp:
            right = right - 1
       	data[left] = data[right]
         # 如果最左边的值小于中间值，则最左边值往前进一个位置，反之，就将值赋值给最右边位置
        while left < right and data[left] <= temp:
            left = left + 1
       	data[right] = data[left]
    # 循环结束，即可定位到中间位置，将初始值，赋值到这个位置
    data[left] = temp
    return left
            
def quick_sort(data,left,right):
    if left< right:
        mid = partition(data,left,right)
        quick_sort(data,left,mid)
        quick_sort(data,mid+1,right)

冒泡、选择、插入的时间复杂度为O(n^2)；

快速排序的时间复杂度为O(nlogn)

希尔排序

希尔排序是一种分组插入排序算法

首先，取一个d1 = n // 2的整数，将元素分为d1个组，每组相邻元素之间的距离为d1，在各组内进行直接插入排序；

然后，取第二个整数d2 = d1 // 2，重复上述分组排序过程，直到d1 = 1，再将所有元素在同一组内直接插入排序。

希尔排序每趟并不使某些元素有序，而是使整体数据越来越接近有序；最后一趟排序使得所有数据有序。

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

希尔排序的时间复杂度为：O((1+T)n) 约等于 O(1.3n)

计数排序

新增一个值全部为0的列表(数组),再利用enumerate得到该列表的索引和值来排序;

def count_sort(data):
    count = [0 for _ in range(len(data)+1)]
    for i in data:
        count[i] += 1
    data.clear()
    for index, nums in enumerate(count):
        for j in range(nums):
            data.append(index)