排序算法

# 时间复杂度

print("Hello world")  # O(1)

for i in range(n):
    print("Hello world")  # O(n)

for i in range(n):
    for j in range(n):
        print("Hello world")  # O(n ** 2)

for i in range(n):
    for j in range(n):
        for k in range(n):
            print("Hello world")  # O(n ** 3)

for i in range(n):
    for j in range(i):
            print("Hello world")  # O(n ** 2)

n = 64
while n > 1:
    print(n)
    n = n // 2  # O(logn) 
# 循环减半的过程O(logn)

# 时间复杂度排序
# O(1) < O(logn) < O(n) < O(nlogn) < O(n ** 2) < O(n ** 2 logn) < o(n ** 3)



####
"""冒泡排序 选择排序 插入排序"""


# 冒泡排序
# 时间复杂度 O(n ** 2)

def bubble_sort(li):
    # 冒泡排序
    for i in range(len(li) - 1):
        for j in range(len(li) - i - 1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]


# 冒泡排序优化
# 如果一次排序中无数据交换，跳出排序

def bubble_sort(li):
    for i in range(len(li) - 1):
        exchange = False
        for j in range(len(li) - i - 1):
            if li[j] > li[j + 1]:
                li[j], li[j + 1] = li[j + 1], li[j]
                exchange = True
        if not exchange:
            break


# 冒泡排序测试

import random
data = list(range(1000))
random.shuffle(data)  # 打乱列表
print(data)
bubble_sort(data)
print(data)


# 选择排序
# 时间复杂度 O(n ** 2)

def select_sort(li):
    # 选择排序
    for i in range(len(li) - 1):
        min_loc = i
        for j in range(i + 1, len(li)):
            if li[j] < li[min_loc]:
                min_loc = j
        li[i], li[min_loc] = li[min_loc], li[j]


# 插入排序
# 时间复杂度 O(n ** 2)

def insert_sort(li):
    # 插入排序
    for i in range(1, len(li)):
        tmp = li[i]
        j = i - 1
        while j >= 0 and li[j] > tmp:
            li[j + 1] = li[j]
            j = j - 1
        li[j + 1] = tmp


####
"""快速排序
选择第一个元素，从数组right向左找第一个小于它的元素，交换位置。然后left向右找第一个大于它的元素交换位置。循环，直到左右游标重合。"""


# 快速排序
# 时间复杂度O(nlogn)
def quick_sort(data, left, right):
    # 快速排序
    if left < right:
        mid = partition(data, left, right)
        quick_sort(data, left, mid - 1)
        quick_sort(data, mid + 1, right)


def partition(data, left, right):
    tmp = data[left]
    while left < right:
        while left < right and data[right] >= tmp:
            right -= 1
        data[left] = data[right]
        while left < right and data[left] <= tmp:
            left +=1
        data[right] = data[left]
    data[left] = tmp
    return left


"""堆排序
通过完全二叉树，使得每一个根节点大于子节点，从二叉树中提取元素进行排序。
父节点与左子节点关系i <=> 2i+1
父节点与右子节点关系i <=> 2i+2"""


# 堆排序
def sift(data, low, high):
    # 选择
    i = low        # 父节点
    j = 2 * i + 1  # 左子节点
    tmp = data[i]
    while j <= high:                            # 只要节点还在树里
        if j < high and data[j] < data[j + 1]:  # 左子节点和右子节点比较
            j += 1             # 右子节点大，j替换成右子节点
        if tmp < data[j]:      # 子节点比根节点大
            data[i] = data[j]  # 子节点填到父节点位置
            i = j              # 子节点成为父节点
            j = 2 * i + 1      # 新子节点
        else:
            break
    data[i] = tmp  # 根节点放到父节点位置


def heap_sort(data):
    # 堆排序
    n = len(data)
    for i in range(n // 2 - 1, -1, -1):      # 每一个堆
        sift(data, i, n - 1)                 # 父节点到堆的最后节点
    for i in range(n - 1, -1, -1):           # i指向堆最后
        data[0], data[i] = data[i], data[0]  # 根节点和最后换位
        sift(data, 0, i - 1)                 # 调整出新排序


# 堆排序测试
data = list(range(10000))
random.shuffle(data)  # 打乱列表
print(data)
heap_sort(data)
print(data)