python-十大排序算法源代码

1. 冒泡排序(Bubble Sort)

def bubble_sort(arr):
    length = len(arr)
    for i in range(0,length-1):
        # print('Iteration '+str(i)+' '+str(arr))
        for j in range(0, length-i-1):
            if arr[j]>arr[j+1]:  # swap
                tmp = arr[j]
                arr[j] = arr[j+1]
                arr[j+1] = tmp
    return arr

 

2. 选择排序(Selection Sort) 

def selection_sort(arr):
    length = len(arr)
    for i in range(0, length - 1):
        # print('Iteration ' + str(i) + ' ' + str(arr))
        tmp_min_ind = i
        for j in range(i+1, length):
            if arr[j] < arr[tmp_min_ind]:
                tmp_min_ind = j
        tmp = arr[i]
        arr[i] = arr[tmp_min_ind]
        arr[tmp_min_ind] = tmp
    return arr

3. 插入排序

def insertion_sort(arr):
    length = len(arr)
    for i in range(1, length):
        print('Iteration ' + str(i-1) + ' ' + str(arr))
        cur = arr[i]
        ind = i - 1
        while ind >= 0 and arr[ind] > cur:
            arr[ind+1] = arr[ind]
            ind -= 1
        arr[ind + 1] = cur
    return arr

4. 希尔排序 (Shell Sort)

def shell_sort(arr, increment):
    length=len(arr)
    while True:
        j = 0
        while j<increment:
            for i in range(j, length, increment):
                cur = arr[i]
                ind = i - increment
                while ind >= 0 and arr[ind] > cur:
                    arr[ind + increment] = arr[ind]
                    ind -= increment
                arr[ind + increment] = cur
            j += 1

        # print('Increment =  ' + str(increment) + ' ' + str(arr))
        if increment==1:
            break
        increment=increment//3+1
    return arr

5.归并排序 (Merge Sort)

def merge_sort(arr):
    def merge(arr1, arr2):  # 按序归并
        res=[]
        p1=0
        p2=0
        while p1<len(arr1) and p2<len(arr2):
            if arr1[p1]<arr2[p2]:
                res.append(arr1[p1])
                p1 += 1
            else:
                res.append(arr2[p2])
                p2 += 1
        if p1 < len(arr1):
            res+=arr1[p1:]
        if p2 < len(arr2):
            res+=arr2[p2:]
        return res

    def rec(arr):  # 递归
        length = len(arr)
        if length == 1:
            return arr
        arr[0:length//2] = rec(arr[0:length//2])
        arr[length//2:] = rec(arr[length//2:])
        arr=merge(arr[0:length//2], arr[length//2:])
        return arr

    print(rec(arr))
    return rec(arr)

6. 快排（Quick Sort）

def quick_sort(arr):
    def partition(arr, low, high):
        pivot=arr[low]
        while low<high:
            while low<high and arr[high]>=pivot:
                high-=1
            arr[low]=arr[high]
            while low<high and arr[low]<=pivot:
                low+=1
            arr[high]=arr[low]
            # print(arr)
        arr[low]=pivot
        return arr,low

    def qs(arr, low, high):
        if low<high:
            arr,pivot_i=partition(arr, low, high)
            arr=qs(arr, low, pivot_i)
            arr=qs(arr, pivot_i+1, high)
        return arr

    qs(arr,0,len(arr)-1)
    print(arr)
    return arr

7.堆排序（Heap Sort）

def heap_sort(arr):
    def heapify(arr, start, end):
        tmp = arr[start]
        i = start
        j = 2 * i
        while j <= end:
            if j < end and arr[j]<arr[j+1]:
                j += 1
            if tmp < arr[j]:
                arr[i] = arr[j]
                i = j
                j = 2 * i
            else:
                break
        arr[i] = tmp

    def swap(arr, i, j):
        arr[i], arr[j]=arr[j], arr[i]

    length = len(arr)
    arr.insert(0, 0)  # 序列前边插一个元素，使得原来的序列首的index=1
    first_sort_count = length//2
    for i in range(first_sort_count):  # 把初始的完全二叉树变成大根堆
        heapify(arr, first_sort_count - i, length)
    for i in range(length - 1):  # 交换首尾，尾部的节点已排序，把剩余的完全二叉树变成大根堆
        swap(arr, 1, length - i)
        heapify(arr, 1, length - i -1)
    print(arr[1:])
    return arr[1:]

8.计数排序（Counting Sort）

def counting_sort(arr):
    min_val=min(arr)
    max_val=max(arr)
    C = [0 for _ in range(max_val-min_val+1)]
    for i in arr:
        C[i-min_val]+=1
    ind = 0
    for i in range(len(arr)):
        while C[ind] == 0:
            ind += 1
        arr[i] = ind + min_val
        C[ind] -= 1
    print(arr)
    return arr

9.桶排序（Bucket Sort）

def bucket_sort(arr, bucket_N):
    min_value=min(arr)
    max_value=max(arr)
    bucket_count=(max_value-min_value+1)//bucket_N+1
    buckets=[[] for _ in range(bucket_N)]
    for i in range(len(arr)):
        buckets[(arr[i]-min_value)//bucket_count].append(arr[i])
    print(buckets)
    arr = []
    for b in buckets:
        b = insertion_sort(b)  # 每个桶插入排序（也可使用其他方法）
        arr += b
    print(arr)
    return arr

10.基数排序（Radix Sort）

def radix_sort(arr):
    length=len(arr)
    print(arr)
    r =- 1
    max_value = max(arr)
    while max_value:
        max_value=max_value//10
        r += 1
    j=0
    while j<=r:
        radix = [[] for _ in range(10)]
        dev = 10**j
        rem = 10*dev
        for i in range(length):
            radix[arr[i]%(rem)//(dev)].append(arr[i])
        arr = []
        for i in radix:
            arr += i
        j+=1
        print(arr)