#堆排
def sift(li, low, high):
'''
:param li:树
:param low: 树的根节点
:param high: 树的最后一个节点
:return:向下调整树
'''
tmp = li[low] # 去除树根作为临时变量
i = low # i指向空位
j = 2 * i + 1 # 第一次 j指向根节点的左孩子
while j <= high: # 循环继续的条件：j不越界；This the second end condition：j越界
# 1.比较左右子节点
if j + 1 <= high and li[j] < li[j + 1]: # 右节点存在，才进行左右比较
j += 1 # 将j指向j+1
if li[j] > tmp: # 调整位置
li[i] = li[j] # 空位的元素填成j下标的元素，所谓的调整
i = j # 向下调整
j = 2 * j + 1 # 从当前j节点找左孩子
else:
break # j位置的元素>tmp 停止循环，This the first end condition
li[i] = tmp # 结束循环，空位填充tmp
#堆排
def heak_sort(li):
n = len(li)
# 1.构造堆
for low in range((n - 2) // 2, -1, -1): # 根据子节点找父节点i-->(i-1)//2
sift(li, low, n - 1)
print(li)
# 2.挨个出数
for high in range(n - 1, -1, -1):
li[0], li[high] = li[high], li[0]
sift(li, 0, high - 1) # 排除堆中的最后一个元素
li = [8, 1, 2, 6, 3, 7]
heak_sort(li)
print(li) # [1, 2, 3, 6, 7, 8]
#冒泡排序 时间复杂度O(n*n)
def bubble_sort(li):
for i in range(len(li)): # 表示躺数n躺
flag = False
for j in range(len(li) - 1 - i): # 表示第n躺无序区的范围 0--n-i-1
if li[j] > li[j + 1]:
li[j], li[j + 1] = li[j + 1], li[j]
flag = True
if not flag: # 表示无序区已经有序
break
return li
# 选择排序
'''思路：选择一个最小的val，和无序区的第一个元素进行，交换.时间复杂度O(n*n)'''
def select_sort(li):
for i in range(len(li)):
min_pos = i
for j in range(i + 1, len(li)):
if li[j] < li[min_pos]:
min_pos = j # 更新最小值的下标
li[i], li[min_pos] = li[min_pos], li[i]
return li
# 插入排序
'''思路：选择一个数，和有序区的元素进行比较，如果小于有序区的元素，就将每一个元素向后挪（1.比较的下标<0;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: # ***必须是j>=0 and li[j]>tmp 否则li[-1]会error
li[j + 1] = li[j] # 向后挪
j -= 1 # 向前找一个
li[j + 1] = tmp # 找到符合条件的下标j，后面一个空位即tmp的位置
return li
# 快速排序
def quick_sort(li, left, right):
'''nlogn'''
if left < right:
# 归为元素下标
mid = partition(li, left, right) # 归位
quick_sort(li, left, mid - 1) # 排 mid 左边的元素
quick_sort(li, mid + 1, right) # 排mid右边元素
return li
def partition(li, left, right):
'''O(n)'''
tmp = li[left]
while left < right: # 排序区至少有2个元素
while left < right and li[right] > tmp: # 从右边往左走，
# if left == right:
# break
right -= 1
li[left] = li[right] # 丢到左边
while left < right and li[left] < tmp: # left=3 越界 此时li[2]=li[3]
# if left == right:
# break
left += 1 # 加等完事儿后注意越界问题,left！！！
li[right] = li[left] # 丢到右边 越界导致问题----
# 退出循环left == right ==mid
li[left] = tmp # 丢到右边 越界导致问题---- li[3]=tmp 导致【1,2,4,3,5】
return left
print(quick_sort([2,1,4,3,5],0,4))
# 归并排序.：先分解在merge
# 归并：时间复杂度O(n)；空间复杂度O（n） 条件：一个列表中前后部分是有序的的[2,5,7,8,9,1,3,4,6,]
def merge(li, low, mid, high):
"""
思路：分别比较两段列表的每个元素的位置，如果谁小，谁添加进li_tmp;最后两边的列表会剩下，依次循环append即可
:param li:排序的列表
:param low: 开始的位置
:param mid: 有序的分段的位置
:param high: 结尾的位置
:return:
"""
li_tmp = []
i = low
j = mid + 1
while i <= mid and j <= high: # 考虑 = 的情况，最后j+1后 j=8;所有必须<=防止少
if li[i] < li[j]:
li_tmp.append(li[i])
i += 1
if li[j] < li[i]:
li_tmp.append(li[j])
j += 1
# 剩下的元素
while i <= mid:
li_tmp.append(li[i])
i += 1
while j <= high:
li_tmp.append(li[j])
j += 1
li[low:high + 1] = li_tmp
return li
# 归并排序O(nlog(n))
def merge_sort(li, low, high):
if low < high:
mid = (low + high) // 2
# print(li[low: mid + 1], li[mid + 1: high])
# 分解左边
merge_sort(li, low, mid)
# 分解右边
merge_sort(li, mid + 1, high)
# print(li[low: mid + 1], li[mid + 1: high])
# 归并
merge(li, low, mid, high)
print(li[low: mid + 1], li[mid + 1: high])
li = [2, 5, 7, 8, 9, 1, 3, 4, 6]
merge_sort(li, 0, 8)
print(li)