NB三人组及其时间复杂度

# 快速排序
# 时间复杂度： O(nlogn)
# 最坏情况： o(n2)
# li = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# 递归最大深度问题
# 设置递归最大深度问题、、
# import sys
# sys.setrecursionlimit(1000000)
'''
取一个元素P,使元素P归位
列表被分成了两半，左边都比P小，右边都比P大
递归
'''

print('---------------')


def partition(data, left, right):
    tmp = data[left]
    while left < right:
        while left < right and data[right] >= tmp:  # 从右边找比tmp小的数
            right -= 1  # 往左走一步
        data[left] = data[right]  # 把右边的值写到左边的空位上

        while left < right and data[left] <= tmp:  # 从左边找比tmp大的数
            left += 1  # 往右走一步
        data[right] = data[left]  # 把左边的值写到右边的空位上
    data[left] = tmp  # 把tmp归位
    return left


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)
    return data


li = [3, 2, 1, 5, 4, 9, 7, 8, 6]
print(quick_sort(li, 0, len(li) - 1))
print('---------------------')

# 堆排序
# 树结构 ：n个节点组成的集合
# 二叉树
# 节点的度:几个分叉就有几个度
# 树的度：最大节点的度
# 根节点、叶节点、树的深度（高度）
# 孩子节点/父节点
# 子树
# 时间复杂度为O(nlogn)
# 快排比堆排更快
# 内置模块：headq

'''
二叉树：
度不超过2的树
满二叉树：
完全二叉树：从满二叉树中拿走一些叶节点，必须从左到右排列
二叉树的存储方式：
链式存储方式
顺序存储方式（列表存储）父亲找孩子，孩子找父亲   i——》2i+1(左孩子)  i-->2i+2(右孩子)
 
 
堆： 特殊的完全二叉树
大根堆：比孩子节点大
小根堆：比孩子节点小
堆的向下调整性：节点的左右子树都是堆，但是自身不是堆
当根节点的左右子树都是堆时，可以通过一次向下的调整来将其变换成一个堆

堆排序的过程：
挨个出数，选根节点作为棋子，选最后一个


构造堆：
从最后一个叶节点对应的根节点开始，农村包围城市，从小的开始

堆排序的过程：
1、建立堆（构造堆）
2、得到堆顶元素，为最大元素
3、去掉堆顶，将堆最后一个元素放到堆顶，此时可通过一次调整重新使堆有序
4、堆顶元素为第二大元素
5、重复步骤3、直至堆变空

'''


# 向下调整的实现
def sift(data, low, high):
    '''
    :param data: 列表
    :param low: 堆顶根节点的位置
    :param high: 堆最后一个元素的位置
    :return:
    '''

    i = low  # i最开始指向根节点
    j = 2 * i + 1  # 左孩子
    tmp = data[low]  # 把堆顶存起来
    while j <= high:
        if j + 1 <= high and data[j + 1] > data[j]:  # 如果右孩子有并且比较大
            j = j + 1  # j指向右孩子
        if data[j] > tmp:
            data[i] = data[j]
            i = j  # 往下看一层
            j = 2 * i + 1
        else:  # tmp更大,把tmp放在i的位置上
            data[i] = tmp  # 将tmp放在某一级领导位置上
            break
    else:
        data[i] = tmp  # 把tmp放在叶子节点上
    return data


def heap_sort(data):
    n = len(data)
    for i in range((n - 2) // 2, -1, -1):
        # i代表建堆的时候调整的部分的根的下标
        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)
    return data


data = [2, 1, 4, 3, 4, 7, 8, 5, 6, 9]

print(data)

data = heap_sort(data)
print(data)

print('--------------------')
import heapq  # q->queue 优先队列，先进先出
import random

li = list(range(100))
random.shuffle(li)

print(li)
heapq.heapify(li)  # 建堆
n = len(li)
for i in range(n):
    print(heapq.heappop(li), end=' ')

'''
堆排序 --- topk问题  

设计算法得到前k大的数

解决思路：
先排序在切片 o(nlogn)
排序lowB三人组 O(kn)
堆排序思路  o(nlogk)
    取列表前k个元素建立一个小根堆。堆顶就是目前第k大的数
    依次向后遍历列表，对于列表中的元素，如果小于堆顶，则忽略该元素；如果大于堆顶，则将堆顶更换为该元素，并且对堆进行一次调整
    遍历列表所有元素后，倒叙弹出堆顶
    
topk问题：
'''

# 向下调整的实现

# 比较排序
print('\n<-------------------------->')


def sift(data, low, high):
    '''
    :param data: 列表
    :param low: 堆顶根节点的位置
    :param high: 堆最后一个元素的位置
    :return:
    '''

    i = low  # i最开始指向根节点
    j = 2 * i + 1  # 左孩子
    tmp = data[low]  # 把堆顶存起来
    while j <= high:
        if j + 1 <= high and data[j + 1] < data[j]:  # 如果右孩子有并且比较大
            j = j + 1  # j指向右孩子
        if data[j] < tmp:
            data[i] = data[j]
            i = j  # 往下看一层
            j = 2 * i + 1
        else:  # tmp更大,把tmp放在i的位置上
            # data[i] = tmp  # 将tmp放在某一级领导位置上
            break
        # else:
        data[i] = tmp  # 把tmp放在叶子节点上
    return data


def heap_sort(data):
    n = len(data)
    for i in range((n - 2) // 2, -1, -1):
        # i代表建堆的时候调整的部分的根的下标
        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)
    return data


def topk(data, k):
    heap = data[0:k]
    for i in range((k - 2) // 2, -1, -1):
        sift(heap, i, k - 1)

    # 1、建堆

    for i in range(k, len(data) - 1):
        if data[i] > heap[0]:
            heap[0] = data[i]
            sift(heap, 0, k - 1)
    # 2、遍历

    for i in range(k - 1, -1, -1):
        heap[0], heap[i] = heap[i], heap[0]
        sift(heap, 0, i - 1)

    # 3、出数
    return heap


import random

data = list(range(1000))
random.shuffle(data)

print(topk(data, 10))

# 归并排序
# 时间复杂度为 o(nlogn)
# 空间复杂度为 o(n)

'''
假设咱现在的列表 分成两段有序，如何将其和成为一个有序列表
一次归并
'''
print('==========================')


def merge(data, low, mid, high):
    i = low
    j = mid + 1
    li = []
    while i <= mid and j <= high:
        if data[i] <= data[j]:
            li.append(data[i])
            i += 1
        else:
            li.append(data[j])
            j += 1

    # while 执行完，肯定有一个没数了
    while i <= mid:
        li.append(data[i])
        i += 1
    while j <= high:
        li.append(data[j])
        j += 1
    data[low:high + 1] = li


'''
无序的归并排序
用递归

'''


def mergesort(data, low, high):
    if low < high:  # 至少有两个元素，归并
        mid = (high + low) // 2
        mergesort(data, low, mid)  # 左边排好序
        mergesort(data, mid + 1, high)  # 右边排好序
        merge(data, low, mid, high)  # 合并
        # print(data[low:high+1])


# data = [2, 4, 5, 7, 1, 3, 6, 8]
# merge(data, 0, 3, 7)
# print(data)

print('\n=============================>>')
data = list(range(1000))

random.shuffle(data)

print(data)

mergesort(data, 0, len(data) - 1)
print(data)

'''

NB三人组小结
time:
快排<归并排序<堆排序
缺点：
快排：极端情况下排序效率低
归并：需要额外的内存开销
堆排序：在快的排序算法中相对较慢
稳定：
冒泡 、 直接插入、归并
不稳定：
直接选择、快排、堆排序

挨着的换位置的是稳定的
跳着换位置的是不稳定的

递归： 需要用到系统栈

'''