python 排序算法总结：选择排序，冒泡算法，归并排序（后续补充其他算法）

写代码的终极原则：高内聚，低耦合(high cohesion, low coupling)。

函数应该做到无副作用（调用函数后不影响原来的参数）

在这里插入代码片

一，简单排序算法（低级排序算法） —> O(N**2)

1. 简单选择排序 - 每次从剩下的元素中选择最小元素(或最大元素)放到排好序的列表中

def select_sort(items, *, cmp=lambda x1, x2: x1 > x2):
    items = items[:]
    n = len(items)
    for i in range(n):
        point = i  # point指向最小值
        for j in range(i+1, n):
            if cmp(items[point], items[j]):
                point = j
        if point != i:
            items[i], items[point] = items[point], items[i]
    return items


nums3=[1,4,23,67,3,66,69,13]
print('排序前：nums3', nums3) # 排序前：nums3 [1, 4, 23, 67, 3, 66, 69, 13]
print('排序结果：', select_sort(nums3)) # 排序结果： [1, 3, 4, 13, 23, 66, 67, 69]
print('排序后：nums3', nums3) # 排序后：nums3 [1, 4, 23, 67, 3, 66, 69, 13]

2. 简单插入排序 - 一次取元素，但是要将当前元素插入到合适的位置以确保顺序

3. 冒泡排序 - 两两比较，前面大于后面(或者前面小于后面)就交换位置

冒泡排序：通过不管是升序还是降序，每一次从开始遍历都需要两两比较，把这一轮遍历最大或者最小的值放在最后（冒泡）。下一轮遍历开始前时需要遍历的长度减1。

# 函数应该做到无副作用（调用函数后不影响原来的参数）
def bubble_sort(items, *, cmp=lambda x, y: x > y):
    items = items[:]# 相当于深拷贝
    n = len(items)
    for i in range(n - 1):
        swapped = False
        for j in range(n - 1 - i):
            if cmp(items[j], items[j + 1]):
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
        if not swapped:
            break
    return items

                
nums = np.random.randint(1, 100, 8).tolist()
print('排序前nums:', nums) # 排序前nums: [23, 81, 69, 46, 36, 11, 10, 16]
print('排序结果:', bubble_sort(nums)) # 排序结果: [10, 11, 16, 23, 36, 46, 69, 81]
print('排序后nums:',nums) # 排序后nums: [23, 81, 69, 46, 36, 11, 10, 16]

二，高级排序算法 —> O(N * logN)

1. 快速排序 - 选择枢轴对数据进行划分

2. 归并排序 - 先把列表一分为二，二分为四，拆分到只有一个元素，然后把有序列表两两有序合并

def merge(items1, items2):
    """将两个有序的列表合并成一个新的有序列表"""
    items3 = []
    idx1, idx2 = 0, 0
    while idx1 < len(items1) and idx2 < len(items2):
        a, b = items1[idx1], items2[idx2]
        if a <= b:
            items3.append(a)
            idx1 += 1
        else:
            items3.append(b)
            idx2 += 1
    items3 += items1[idx1:]
    items3 += items2[idx2:]
    return items3


# nums1 = [12, 35, 41, 58, 67, 99]
# nums2 = [10, 11, 20, 30, 40, 50]
# merge(nums1, nums2) # [10, 11, 12, 20, 30, 35, 40, 41, 50, 58, 67, 99]

def merge_sort(items):
    """归并排序"""
    if len(items) <= 1:
        return items[:]
    mid = len(items) // 2
    left, right = items[:mid], items[mid:]
    return merge(merge_sort(left), merge_sort(right))

nums3 = [1,4,23,67,3,66,69,13]
print('排序前：nums1', nums3)
print('排序结果：', merge_sort(nums3))
print('排序后：nums1', nums3)

# 排序前：nums1 [1, 4, 23, 67, 3, 66, 69, 13]
# 排序结果： [1, 3, 4, 13, 23, 66, 67, 69]
# 排序后：nums1 [1, 4, 23, 67, 3, 66, 69, 13]

3. 堆排序 - 建立一个堆结构（树，层次结构），按层次组织元素

Python内置的sorted使用的是？？？—> TimSort（多核版的归并排序）