数据结构与算法
算法衡量的标准：
1.时间复杂度：
两个程序的运行时间如何衡量？
答：用time模块来判断，time.time()来进行计算，前提是两段程序必须运行在同一个硬件相同（cpu）的环境下，才会有意义
因此，我们使用时间差的方式来衡量一个程序是否快慢没有任何的意义。所以使用程序执行的大概次数，来衡量程序的执行快慢，这种衡量的方式称之为时间复杂度，使用O()来记
如何判断时间复杂度？
循环减半的过程O(logn)
几次循环就是n的几次方的复杂度
2.空间复杂度：
这段程序运行的过程，是否占用了内存空间
常见的排序算法
算法：
排序算法：
冒泡排序
选择排序
插入排序
快速排序
希尔排序
桶排序（计数排序）
动态规划 贪心（分糖果，人民币问题） 背包问题
查找：
顺序查找
二分查找
# 冒泡排序
# 时间复杂度：最差的情况：O(n^2) 最好的情况：O(n)
# 空间复杂度: O(1)
# 先找到最大的数放列表末尾位置，从右往左排
def bubble_sort(li):
for i in range(len(li) - 1):
for j in range(len(li) - 1 - i):
if li[j] > li[j + 1]:
li[j], li[j + 1] = li[j + 1], li[j]
# 改良
def bubble_sort2(li):
for i in range(len(li) - 1):
flag = True
for j in range(len(li) - 1 - i):
if li[j] > li[j + 1]:
li[j], li[j + 1] = li[j + 1], li[j]
flag = False
if flag:
return
# 选择排序
# 时间复杂度是： O（n^2）
# 先找到最小的数放在列表的起始位置，从左往右排
def select_sort(li):
for i in range(len(li)):
minloc = i
for j in range(i + 1, len(li)):
if li[minloc] > li[j]:
li[minloc], li[j] = li[j], li[minloc]
# 插入排序
# 时间复杂度： 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
# 快速排序
# 时间复杂度： O(nlogn）
def partition(li, left, right):
tmp = li[left]
while left < right:
while left < right and li[right] >= tmp:
right = right - 1
li[left] = li[right]
while left < right and li[left] <= tmp:
left = left + 1
li[right] = li[left]
li[left] = tmp
return left
def quick_sort(li, left, right):
if left < right:
mid = partition(li, left, right) # 归位函数
quick_sort(li, left, mid - 1)
quick_sort(li, mid + 1, right)
li = [7, 5, 4, 6, 3, 8, 2, 9, 1]
# li = [1, 2, 3, 4, 5, 6]
# bubble_sort(li)
# select_sort(li)
# select_sort(li)
quick_sort(li, 0, len(li)-1)
print(li)