Python之八大排序算法实现

排序算法

 

一.快速排序

# 递归有返回
def Qsort(L):
    if len(L) <= 1: return L
    return Qsort([low for low in L[1:] if low < L[0]]) + L[0:1]+ \
    Qsort([high for high in L[1:] if high >= L[0]])

 

# 非递归无返回
def quick_sort(L, low, high):
    key = L[low]
    while low < high:
        while low < high and L[high] >= key:
            high -= 1
        L[low] = L[high]
        while low < high and L[low] <= key:
            low += 1
        L[high] = L[low]
    L[low] = key

    return low

def Qsort(L, low, high):
    if low < high:
        pivotloc = qucksort(L, low, high)
        Qsort(L, low, pivotloc-1)
        Qsort(L, pivotloc+1, high)

 

二.冒泡排序

概念：重复走访待排数列，一次比较两个元素，若顺序错误就互相交换，直到走访到末尾，排序完成。（每次走访数列都会将数列中较大的数通过交换'浮'到数列的尾端，故名冒泡排序）。

思路：

1. 遍历列表，对其中每一对相邻的两个元素进行比较，若第一个比第二个大就进行交换。

2.通过第一步将最大的元素交换到列表末尾，然后排除该元素，对前面的所有元素进行第1步操作。

3.重复进行前面两步操作。

# 双重for循环
def bubble_sort(A):
    length = len(A)
    for index in range(length):
        for i in range(1, length-index):
            if A[i-1] > A[i]:
                A[i-1], A[i] = A[i], A[i-1]
    return A
    

# for循环嵌套while循环
def bubble_sort(A):
    length = len(A)
    for i in range(length):
        j = 1
        while j < length-i:
            if A[j-1] > A[j]:
                A[j-1], A[j] = A[j], A[j-1]
    return A        

# 反过来排序
def bubble_sort(A):
    length = len(A)
    for i in range(length):
        j = length-1
        while j >= i:
            if A[j] < A[j-1]:
                A[j], A[j-1] = A[j-1], A[j]
            j -= 1
    return A    

# 优化算法
def bubble_sort(A):
    length = len(A)
    for index in range(length):
        flag = True
        for i in range(1, length-index):
            if A[i-1] > A[i]:
                A[i-1], A[i] = A[i], A[i-1]
                flag = False
        if flag:
            return A
    return A

三.选择排序

概念：从待排数列中选出最大（或最小）的一个元素，存放在数列的起始位置，直至数列排完。

思路：

1.将列表中第一个元素与其后所有元素进行比较，碰到较小的便与之交换。

2.排除第1步中选出的元素，对剩下的元素进行第1步操作。

3.重复上述操作。

# 双重for循环
def select_sort(A):
    length = len(A)
    for index in range(length):
        for i in range(index+1, length):
            if A[index] > A[i]:
                A[index], A[i] = A[i], A[index]
    return A

 

四.插入排序

概念：第一个元素必有序，将数组中未排序的元素插入到有序的元素中，从而得到一个新的有序数组。

思路：

第一个元素为有序元素，将后面的元素依次记为待插入元素，与前面的有序元素从后至前比较，然后进行插入。

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

def insert_sort(A):
    length = len(A)
    for i in range(1, length):
        key = A[i]
        j = i
        while j >= 1 and A[j-1] > key:
                A[j] =  A[j-1]
                j -= 1
        A[j] = key
    return A

五.归并排序

概念：将两个有序数组归并为一个有序数组。

思路

1.创建一个新数组，将第一个数组的每个元素与第二个数组的每个元素进行比较，将每次比较中较小的元素添加到新数组中，直至第一个数组的所有元素比较完。

2.若第二个数组的元素未比较完，则将第二个数组剩下的元素添加到新数组中。

def merge_sort(A, B):
    len1 = len(A)
    len2 = len(B)
    C = []
    j = 0
    for i in range(len1):
        while j < len2 and A[i] > B[j]:
            C.append(B[j]) 
            j += 1
        C.append(A[i])
    if j < len2:
            C.extend(B[j:]) # C = C + B[j:]
    return C

 

六.希尔排序

优化版插入排序

# 希尔排序
def shell_sort(A):
    length = len(A)
    gap = length // 2
    while gap > 0:
        for i in range(gap, length):
            temp = A[i]
            j = i
            while j >= gap and A[j-gap] > temp:
                A[j] = A[j-gap]
                j -= gap
            A[j] = temp
        gap //= 2
        print(A)
    return A

A = [1, 2, 4, 1, 3, 6, 4, 5, 9]
shell_sort(A)


[1, 2, 4, 1, 3, 6, 4, 5, 9]      
[1, 1, 3, 2, 4, 5, 4, 6, 9]
[1, 1, 2, 3, 4, 4, 5, 6, 9]
[1, 1, 2, 3, 4, 4, 5, 6, 9]

 

七.堆排序

八.计数排序

def count_sort(A):
    Max = Min = 0
    for each in A:
        if each < Min:
            Min = each
        if each > Max:
            Max = each
    count = [0] * (Max-Min+1)
    # 将A中元素出现的次数放入count中
    for i in A:
        count[i-Min] += 1
    index = 0
    for j in range(Max-Min+1):
        for k in range(count[j]):
            A[index] = j+Min
            index += 1
    return A