Python 快速归并堆基数排序

1、快速排序

  （1 数列中选择基准数字

  （2 其他元素与基准比较，比基准小的放左边，大的放右边

  （3 递归（2） 

#快排
def quick_sort(data):
    if (len(data)) < 2: #递归直到数列里面只有一个数
        return data
    else:
        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) #递归
    
data = [1,2,9,10,3,4,7,8,0,5,6]
print(quick_sort(data))

 

2、归并排序

  （1 将数列分为各个子序列，使用中间的基数

  （2 比较两个子序列的值，直到其中一个序列到达结尾

  （3 按照比较的大小依次存入数组

#归并排序
#分为子序列
def merge_sort(data):
    if len(data) <= 1: #递归直到只剩一个元素时返回
        return data
    else:
        num = len(data)//2 #选择基数
        left = merge_sort(data[:num]) #左侧序列继续递归
        right = merge_sort(data[num:]) #右侧序列继续递归
        return merge(left, right) #排序
#合并
def merge(left, right): 
    result = [] #定义一个数列存放已排好序的数
    l, r =0, 0
    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

data = [1,2,9,10,3,4,7,8,0,5,6]
print(merge_sort(data))

 

3、堆排序

  需要满足父结点 大于 子结点

  （1 建立初始堆

  （2 子结点与父结点比较，若比父结点大则交换

  （3 将堆的顶元素放入最后，纳入有序堆，其他继续建堆

 

#堆排序
def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1 #左孩子
    r = 2 * i + 2 #右孩子
    
    if l < n and arr[l] > arr [i]: #左子结点大于父结点
        largest = l
    
    if r < n and arr[r] > arr[largest]: #右子结点大于父结点
        largest = r
    
    if largest != i: #如果最大值不是父结点
        arr[i], arr[largest] = arr[largest], arr[i] #交换
        
        heapify(arr, n, largest) #继续

def heap_sort(arr):
    n = len(arr)
    
    # 建初始堆
    for i in range(n, -1, -1):
        heapify(arr, n, i)
    
    print(arr)
    
    # 将最大元素纳入有序堆，其余继续比较 循环
    for i in range(n-1, 0, -1): 
        arr[i], arr[0] = arr[0], arr[i]   # 交换
        heapify(arr, i, 0) 

arr = [ 18, 8, 5, 39, 20, 10] 
heap_sort(arr) 
n = len(arr) 
print ("排序后") 
print(arr)
    

 

4、基数排序

就是从个位数开始按照0-9顺序排，依次是十位数，百位数....

  （1  找出最大数位数

  （2 从个位数开始循环 将排好序的数字放入字典中（桶排序方法）

  （3 再将数字从桶中依次取出，放入数组

#基数排序
import math
def radix_sort(arr):
    count = 1
    max_num = max(arr) #最大的数
    
    while max_num > 10**count: #求最大位数
        count =  count + 1 
    
    n = 0
    while n < count : #循环到最大位数
        bucket = {} #方便进行桶排序
        for i in range(0,10): #开始之前清空桶
            bucket.setdefault(i,[])
        
        for num in arr: #按照0-9放入相对应的桶中
            index = int((num/(10**n))%10)
            bucket[index].append(num)
        
        k = 0
        for i in range(10): #0-9的桶中去除数字
            length = len(bucket[i]) 
            if length != 0: #若桶中非空
                for num in bucket[i]: #将数依次放入数组
                    arr[k] = num
                    k = k+1
        n = n+1
        

if __name__ == '__main__':
    arr = [ 19, 18, 18, 8, 5, 39, 20, 10] 
    print(arr)
    radix_sort(arr)
    print(arr)