7.python实现快速排序和归并排序

快速排序

from typing import List


def quick_sort(arr: List, left, right) -> List:
    """
    快速排序是对冒泡排序的改进，核心思想是找到一个中值点pivot，然后将小于等于pivot的放在pivot的左边，大于pivot的放在右边，一直递归到无法拆分pivot点。
    :param arr:
    :return:
    """
    pivot = (left + right) // 2
    pivot_value = arr[pivot]
    l = left
    r = right
    while l < r:
        while arr[l] < pivot_value:
            l += 1
        while arr[r] > pivot_value:
            r -= 1
        arr[l], arr[r] = arr[r], arr[l]
        if l == r:
            break
        if arr[l] == pivot_value:
            r -= 1
        if arr[r] == pivot_value:
            l += 1

    # 向右递归
    if l < right:
        quick_sort(arr, l + 1, right)
    if r > left:
        quick_sort(arr, left, r - 1)


if __name__ == '__main__':
    arr = [4, 1, 5, 7, 6, -1, 55, -55, 666]
    quick_sort(arr, 0, len(arr) - 1)
    print(arr)

归并排序

from typing import List


def merge_sort(arr: List, left, right) -> List:
    """
    核心思想:拆分和合并，拆分其实只干了一件事将数组2等份，一直拆分到无法拆分为止，
    合并在于从最小拆分单元先排序，然后向上合并再排序，
    最终得到一个有序数组。分支算法采用的递归操作，核心代码在于合并。
    :param arr:
    :return:
    """
    mid = (left + right) // 2
    left_num = arr[left:mid]
    right_num = arr[mid: right]
    # 拆分
    if len(left_num) > 1:
        left_num = merge_sort(arr, left, mid)
    if len(right_num) > 1:
        right_num = merge_sort(arr, mid, right)

    l_index = 0
    r_index = 0
    temp = []
    while l_index < len(left_num) and r_index < len(right_num):
        if left_num[l_index] < right_num[r_index]:
            temp.append(left_num.pop(l_index))
            l_index += 1
        else:
            temp.append(right_num.pop(r_index))
            r_index += 1
        # 因为使用的pop操作,数组每次都会弹出一个元素 下次循环挑选元素的时候重新将指针指向数组开头
        l_index = 0
        r_index = 0
    # 剩余数组追加
    temp.extend(left_num)
    temp.extend(right_num)
    return temp


if __name__ == '__main__':
    arr = [4, 1, 5, 7, 6, -1, 55, -55, 666]
    print(merge_sort(arr, 0, len(arr)))
    print(arr)