python-排序&优化

 

(图片链接：https://medium.com/@george.seif94/a-tour-of-the-top-5-sorting-algorithms-with-python-code-43ea9aa02889)

 

# arr = [1, 3, 5, 7, 2, 4, 6, 8]
arr = [3, 4, 2, 1, 5, 6, 7, 8]


def bubble_sort0(arr):
    """方法一：最粗糙的 冒泡排序，每次循环把最大的数放在最后， 28次"""
    compare_count = 0
    length = len(arr)
    for i in range(length - 1):
        for j in range(length - 1 - i):
            compare_count += 1
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    print(arr, compare_count)
    return arr


def bubble_sort1(arr):
    """方法二：设置了一个标志位，进行判断，用来退出循环， 22次"""
    compare_count1 = 0
    length = len(arr)
    for i in range(length - 1):
        swapped = False
        for j in range(length - 1 - i):
            compare_count1 += 1
            t1 = arr[j]
            t2 = arr[j + 1]
            if t1 > t2:
                swapped = True
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
        if not swapped:
            break
    print(arr, compare_count1)
    return arr


def bubble_sort2(arr):
    """方法三：在方法二的基础上，加入有序无序边界判定，10次"""
    compare_count2 = 0
    length = len(arr)-1
    last_change = 0
    boder = length
    for i in range(length):
        swapped = False
        for j in range(boder):
            compare_count2 += 1
            t1 = arr[j]
            t2 = arr[j + 1]
            if t1 > t2:
                swapped = True
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                last_change = j
        if not swapped: break
        boder = last_change
    print(arr, compare_count2)
    return arr




# arr0 = bubble_sort0(arr)  # 28
print("----")
arr1 = bubble_sort1(arr)  # 22
print("----")
# arr2 = bubble_sort2(arr)  # 10

 

#归并

# 插入

# 选择

# 冒泡

# 快排

# 堆排

图片链接：https://medium.com/@parulbaweja8/a-closer-look-at-heapsort-c83b331f8353

def bubble_sort(arr):
    """冒泡排序：带边界，带标志位判定"""
    boder = len(arr) - 1
    last_change = 0
    for i in range(len(arr) - 1):
        swapped = False
        for j in range(boder):
            if arr[j] > arr[j + 1]:
                swapped = True
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                last_change = j
        if not swapped: break
        boder = last_change
    return arr


def selection_sort(arr):
    """选择排序, 每次选出最小的的那个index，交换"""
    for i in range(len(arr)):
        min = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min]:
                min = j
        arr[i], arr[min] = arr[min], arr[i]
    print(arr)
    return arr


def insert_sort(arr):
    """插入排序，从第一个开始往前搜索何时的位置，注意元素后挪"""
    for i in range(1, len(arr)):
        cursor = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > cursor:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = cursor
    print(arr)
    return arr


# 归并排序： 本质上是 合并2个有序数组 + 分治的思想
def merge(left, right, merged):
    """2个已经排好序的 left，right数组，单个数字也算排好序"""
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            merged[i + j] = left[i]
            i += 1
        else:
            merged[i + j] = right[j]
            j += 1

    for i in range(i, len(left)):
        merged[i + j] = left[i]

    for j in range(j, len(right)):
        merged[i + j] = right[j]
    return merged


def merge_sort(arr):
    """把无序数组排序好，最终分治为2个数（数组）"""
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left, right = merge_sort(arr[:mid]), merge_sort(arr[mid:])
    new = merge(left, right, arr.copy())
    return new


# 快排 本质上是无序数组按某个值划分为2侧 + 分治的思想
def partition(L, left, right):
    """将数组按 某个值 进行左右分割"""
    pivot = L[left]
    while left < right:
        while left < right and L[right] >= pivot:
            right -= 1
        L[left] = L[right]
        while left < right and L[left] <= pivot:
            left += 1
        L[right] = L[left]
    L[left] = pivot
    return left


def q_sort(L, left, right):
    if left < right:
        pivot_index = partition(L, left, right)
        print("pivot_index = ", pivot_index)

        q_sort(L, left, pivot_index - 1)
        q_sort(L, pivot_index + 1, right)
    return L


def quick_sort(L):
    return q_sort(L, 0, len(L) - 1)


# 堆排序: 主要是 完全二叉树公式->构建堆(heapify) + 交换头尾&heapify
def swap(arr, i, max):
    arr[i], arr[max] = arr[max], arr[i]

def heapify(arr, n, i):
    """对数组(完全二叉树)某个节点进行heapify, n=节点数量, i=需要操作heapify的节点"""
    if i >= n:
        return
    max = i
    c1 = 2 * i + 1
    c2 = 2 * i + 2
    if c1 < n and arr[c1] > arr[max]:
        max = c1
    if c2 < n and arr[c2] > arr[max]:
        max = c2
    if max != i:
        swap(arr, i, max)
        heapify(arr, n, max)

def build_heap(arr):
    length = len(arr)
    last_item_idx = length - 1
    parent_idx = (last_item_idx - 1) // 2
    for i in range(parent_idx, -1, -1):
        heapify(arr, length, i)

def heap_sort(arr):
    build_heap(arr)
    for i in range(len(arr)-1, -1, -1):
        swap(arr, i, 0)
        heapify(arr, i, 0)



if __name__ == "__main__":
    # arr = [1, 3, 5, 7, 2, 4, 6, 8]
    # arr = [1, 7, 2, 4]
    # print(merge_sort(arr))
    # print(quick_sort(arr))

    # heapify -> build_heap -> heap_sort
    # tree = [4, 10, 3, 5, 1, 2]
    # heapify(tree, len(tree), 0)
    #
    # tree = [2, 5, 3, 1, 10, 4]
    # build_heap(tree)
    # print(tree)

    tree = [2, 5, 3, 1, 10, 4]
    heap_sort(tree)
    print(tree)

 

参考链接：

https://www.jianshu.com/p/2b2f1f79984e

https://www.bilibili.com/video/av9982752/

https://www.bilibili.com/video/BV1Eb41147dK/?spm_id_from=333.788.videocard.2