各种排序算法的Python实现

1.冒泡排序

def bubbleSort(values):
    len_ = len(values)
    flag = 1
    
    for i in range(len_ - 1):
        if flag == 1:
            flag = 0
            for j in range(len_ - 1, i, -1):
                if values[j - 1] > values[j]:
                    values[j - 1], values[j] = values[j], values[j - 1]
                    flag = 1
                    
    return values

2.选择排序

def selectSort(values):
    Len = len(values)
    
    for i in range(Len - 1):
        Min = i + 1
        for j in range(i+1, Len):
            if values[j] < values[Min]:
                Min = j
                
        if values[Min] < values[i]:
            values[i], values[Min] = values[Min], values[i]

    return values

3.插入排序

def insertSort(values):
    Len = len(values)
    
    for i in range(1, Len):
        if values[i] < values[i - 1]:
            temp = values[i]
            j = i - 1
            while j >= 0 and temp < values[j]:
                values[j + 1] = values[j]
                j -= 1
            values[j+1] = temp

    return values

   4.希尔排序

def SheelSort(values):
    
    increase = len(values)
    
    while True:
        increase = increase // 3 + 1
        
        for i in range(0, increase):
            
            for j in range(i+increase, len(values), increase):
                if values[j] < values[j - increase]:
                    temp = values[j]
                    k = j - increase
                    while k >= 0 and temp < values[k]:
                        values[k + increase] = values[k]
                        k -= increase
                    
                    values[k + increase] = temp

        if increase <= 1:
            break
        
    return values

    
5.堆排序

def HeapSort(values):
    """堆排序"""
    def siftDown(values, elem, begin, end):
        """
        对元素elem进行向下筛选
        #arguments:
            begin: 起始根节点的下标
            end: 数组长度
            elem: 始终记录着进行向下筛选的元素
            values: 整个数组
        """
        i = begin #该元素的位置
        j = begin * 2 + 1 #初始时先比较根节点与左子树的值
        while j < end: #当存在左子树的时候
            if j+1 < end and values[j+1] > values[j]:#存在右子树，并且右子树的值比左子树大，此时是构造大顶堆
                j += 1 #让备选下标变为右子树的下标
            if elem > values[j]: #当前节点的值比左右子树的最大值还大，则不需要修改
                break
            values[i] = values[j] #当前节点比最大值小，将当前节点更改为最大值
            i = j #交换之后，找到刚才交换的位置
            j = 2 * j + 1 #新的左子树
            
        values[i] = elem #将原来的值存到最后被交换的位置

    #创建大顶堆，此时堆顶为最大值，堆顶即为0位置
    end = len(values) #数组长度
    for i in range((end // 2)-1, -1, -1): #从 (end//2)-1 -> 0，对每个内部元素进行向下筛选
        siftDown(values, values[i], i, end)
    
    #依次取出堆顶，放在末尾
    for i in range((end-1), 0, -1): #从最后一个位置开始，到倒数第二个位置
        e = values[i] #取出最后一个位置的值
        values[i] = values[0] #将最大值，即大顶堆的首位置的值，放入到最后一个位置
        siftDown(values, e, 0, i) #然后剩余的位置为[0-i),此时将取出的值放入到0位置，然后进行向下筛选
        
    return values

6.快速排序   

def QuickSort(values, low, high):
    """快速排序"""
    
    def patition(values, low, high):
        """快速排序的分组算法"""
        if not values or low < 0 or high < 0:
            raise ValueError("Invalid input parameters.")
            
        pivot = low #初始时，让枢轴为起始位置
        values[high], values[pivot] = values[pivot], values[high] #交换pivot与末尾的值，末尾的值变为基准值
        
        pivot = low - 1 #初始时，在low-1处，记录遇到的第一个较大值的位置
        for index in range(low, high, 1): #遍历数组中的第一个到倒数第二个元素
            if values[index] < values[high]: #若遍历到的元素比基准值小
                pivot += 1 # 让第一个较大值的位置往后挪一个，把前面腾出来给较小值
                if pivot != index: #满足此条件时，说明之前遇到了大于等于基准值的元素，否则，不应该交换
                    values[pivot], values[index] = values[index], values[pivot] #交换较小值与之前的较大值
        pivot += 1 
        values[pivot], values[high] = values[high], values[pivot] #交换较大值与基准值

        return pivot
        
        
                
    def patition_1(values, low, high):
        """快速排序的分组算法"""
        if not values or low < 0 or high < 0:
            raise ValueError("Invalid Input.")
            
        pivot = values[low] #取第一个值作为基准值
        while low < high:  #当low和high中间还有元素时
            while low < high and pivot <= values[high]: #从末尾开始，往前寻找一个比基准值小的值
                high -= 1
            values[low] = values[high] #找个之后，存储到low的位置

            while low < high and values[low] <= pivot: #从头开始，往后寻找一个比基准值大的值
                low += 1
            values[high] = values[low] #找到之后，存储到high的位置

        values[low] = pivot #将基准值存入到最终low的位置
        return low  
                

    #执行快排
    if low == high: #只有一个元素时，已有序
        return
    pivot = patition_1(values, low, high) #执行一遍分组，把基准值放到正确位置
    if pivot > low: #基准值的位置与首下标不同，说明基准值左边有元素
        QuickSort(values, low, pivot - 1) #对基准值左侧进行快排
    if pivot < high: #基准值的位置为尾下标不同，说明基准值右边有元素
        QuickSort(values, pivot + 1, high) #对基准值右侧进行快排

 7.归并排序

temp = [None for _ in range(6)]
def MergeSort(values, low, high):
    """归并排序"""

    def Merge(values, low, mid, high):
        """
        对两个序列进行归并
        #arguments:
            values: 整个序列
            第一段的范围是[low, mid]
            第二段的范围是[mid+1, high]
        """
#        for k in range(low, high+1):
#            temp[k] = values[k]
        temp[:] = values[:]

        i = low
        j = mid + 1
        k = i
        while i <= mid and j <= high:
            if temp[i] <= temp[j]:
                values[k] = temp[i]
                i += 1
            else:
                values[k] = temp[j]
                j += 1
                
            k += 1
            
        while i <= mid:
            values[k] = temp[i]
            k += 1
            i += 1
        while j <= high:
            values[k] = temp[j]
            k += 1
            j += 1

            
    #执行归并排序
    if low < high:
        mid = (low + high) // 2
        MergeSort(values, low, mid)
        MergeSort(values, mid+1, high)
        
        Merge(values, low, mid, high)

测试：

if __name__ == "__main__":
    values = [4, 5, 3, 1, 0, 1]

#    re = bubbleSort(values)
#    re = selectSort(values)
#    re = insertSort(values)
#    re = SheelSort(values)
#    re = HeapSort(values)
    re = values
#    QuickSort(re, 0, len(re)-1)
    MergeSort(re, 0, len(re) - 1)
    
    print(re)

各种算法的复杂度