程序员面试算法宝典-8.1~8.8 选择排序、插入排序 、冒泡排序、 归并排序、 快速排序、 希尔排序、 堆排序、 基数排序

# 选择排序
def select_sort(lists):
    count = len(lists)
    for i in range(0, count):
        min = i
        for j in range(i+1, count):
            if lists[min]>lists[j]:
                min = j
        lists[i], lists[min] = lists[min], lists[i]
    return lists

# 插入排序
def insert_sort(lists):
    count = len(lists)
    # 遍历列表后面未排序的数
    for i in range(0, count):
        key = lists[i]
        # 选取未排序的一个数与以排序完成的列表进行插入排序
        j = i - 1
        while j>=0:
            if lists[j]>key:
                lists[j+1] = lists[j]
                lists[j] = key
            j -= 1
    return lists
# 冒泡排序
def bubble_sort(lists):
    count = len(lists)
    for i in range(0, count):
        for j in range(i+1, count):
            if lists[i]>lists[j]:
                lists[i], lists[j] = lists[j], lists[i]
        print(lists)
    return lists
# 归并排序
def merge(left, right):
    i, j = 0, 0
    result = []
    while i<len(left) and j<len(right):
        if left[i]<=right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result
def merge_sort(lists):
    if len(lists)<=1:
        return lists
    num = len(lists)//2
    left = merge_sort(lists[:num])
    right = merge_sort(lists[num:])
    return merge(left, right)
# 快速排序
def quick_sort(lists, left, right):
    if left>right:
        return lists
    key = lists[left]
    low = left
    high = right
    while left<right:
        # 从右开始扫描，如果值大于key则right-1,小于key则交换
        while left<right and lists[right]>=key:
            right -= 1
        lists[left] = lists[right]
        # 从左开始扫描，如果值小于key则left+1,大于key则交换
        while left<right and lists[left]<=key:
            left += 1
        lists[right] = lists[left]
    lists[right] = key
    quick_sort(lists, low, left-1)
    quick_sort(lists, left+1, high)
    return lists
# 希尔排序
def shell_sort(lists):
    count=len(lists)
    step = 2
    group = count//step
    while group>0:
        for i in range(0, group):
            j = i + group
            while j<count:
                k = j-group
                key = lists[j]
                while k>=0:
                    if lists[k]>key:
                        lists[k+group]=lists[k]
                        lists[k] = key
                    k -= group
                j += group
        group = group//step
    return lists
# 堆排序
# import sys
# sys.setrecursionlimit(10000)
def adjust_heap(lists, i, size): # i:结点 size:堆的大小
    lchild = 2*i + 1 # 左孩子
    rchild = 2*i + 2 # 右孩子
    maxs = i
    if i<(size//2):
        if lchild<size and lists[lchild]>lists[maxs]:
            maxs = lchild
        if rchild<size and lists[rchild]>lists[maxs]:
            maxs = rchild
        if maxs!=i:
            lists[maxs], lists[i] = lists[i], lists[maxs]
            adjust_heap(lists, maxs, size)
def build_heap(lists, size):
    for i in range(0, (size//2))[::-1]:
        adjust_heap(lists, i, size)
def heap_sort(lists):
    size = len(lists)
    build_heap(lists, size)
    for i in range(0, size)[::-1]:
        lists[0], lists[i] = lists[i], lists[0]
        adjust_heap(lists, 0, i)

# 基数排序
import math
def radix_sort(lists, radix=10):
    k = int(math.ceil(math.log(max(lists), radix)))
    bucket = [[] for i in range(radix)] # []列表10个,表示10个桶
    for i in range(1, k+1):
        for j in lists:
            bucket[j//(radix**(i-1))%(radix**i)].append(j)
        del lists[:]
        for z in bucket:
            lists += z
            del z[:]
    return lists
def radix_sort1(s):
    """基数排序"""
    i = 0 # 记录当前正在排拿一位，最低位为1
    max_num = max(s)  # 最大值
    j = len(str(max_num))  # 记录最大值的位数
    while i < j:
        bucket_list =[[] for _ in range(10)] #初始化桶数组
        for x in s:
            bucket_list[int(x / (10**i)) % 10].append(x) # 找到位置放入桶数组
        s.clear()
        for x in bucket_list:   # 放回原序列
            for y in x:
                s.append(y)
        i += 1
    print(s)

if __name__=="__main__":
    lists=[3, 4, 2, 8, 9, 5, 1]
    print("排序前序列为：")
    for i in lists:
        print(i, end=" ")
    print("\n排序后序列为：")
    radix_sort1(lists)