# 冒泡排序
# 1.从第一个位置开始比较它与下一个位置的值的大小，前一个大就互换值（升序），直到比较完最后一个位置，确定出最大的数
# 2.除上一步确定出的数外，重复上一步步骤，最后排序完成
def sort_up(list_para):
"""
将传入的列表按升序排序
:param list_para: list
:return: 按升序排序后的列表
"""
for j in range(1, len(list_para)):
for i in range(len(list_para)-j):
if list_para[i] > list_para[i+1]:
list_para[i], list_para[i+1] = list_para[i+1], list_para[i]
return list_para
lis = [2, 5, 1, 6, 8, 7]
x = sort_up(lis)
print(x)
# 快排
# 1.选出一个基准，将大于基准的放在右边，小于的放在左边，完成左边的小于右边的，并且确定了一个中间值
# 2.将上一步确定出的左右两部分别分递归地重复上一步步骤
# first理解为第一个位置的索引，last是最后位置索引
def quick_sort(alist, first, last):
# 递归终止条件
if first >= last:
return
# 设置第一个元素为中间值
mid_value = alist[first]
# low指向
low = first
# high
high = last
# 只要low小于high就一直走
flag = 0
while low < high:
# high大于中间值，则进入循环
while low < high and alist[high] >= mid_value:
# high往左走
high -= 1
# 出循环后，说明high小于中间值,low指向该值
alist[low] = alist[high]
# high走完了，让low走
# low小于中间值，则进入循环
while low < high and alist[low] < mid_value:
# low向右走
low += 1
# 出循环后，说明low大于中间值,high指向该值
alist[high] = alist[low]
if not flag:
print(alist)
# 退出整个循环后，low和high相等
# 将中间值放到中间位置
alist[low] = mid_value
print(alist)
flag = 1
# 递归
# 先对左侧快排
quick_sort(alist, first, low - 1)
# 对右侧快排
quick_sort(alist, low + 1, last)
if __name__ == '__main__':
li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print(li)
quick_sort(li, 0, len(li) - 1)
print(li)
# 归并排序
# 1. 将数组分解最小之后，然后合并两个有序数组。
# 2. 比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。
# 3. 然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
def merge_sort(alist):
n = len(alist)
# 递归结束条件
if n <= 1:
return alist
# 中间位置
mid = n // 2
# 递归拆分左侧
left_li = merge_sort(alist[:mid])
# 递归拆分右侧
right_li = merge_sort(alist[mid:])
# 需要2个游标，分别指向左列表和右列表第一个元素
left_point, right_point = 0, 0
# 定义最终返回的结果集
result = []
# 循环合并数据
while left_point < len(left_li) and right_point < len(right_li):
# 谁小谁放前面
if left_li[left_point] <= right_li[right_point]:
# 放进结果集
result.append(left_li[left_point])
# 游标移动
left_point += 1
else:
result.append(right_li[right_point])
right_point += 1
# 退出循环时，形成左右两个序列
result += left_li[left_point:]
result += right_li[right_point:]
return result
if __name__ == '__main__':
li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print(li)
sort_li = merge_sort(li)
print(li)
print(sort_li)
# 详细的冒泡排序与优化
import time
def bubble_sort(alist):
# 外层循环控制比较几轮
n = len(alist)
for j in range(n - 1):
# 内存循环控制交换
# -j是不再换已经排好的
for i in range(n - 1 - j):
# 若前一个比后一个大，则换
if alist[i] > alist[i + 1]:
alist[i], alist[i + 1] = alist[i + 1], alist[i]
# print(alist)
def bubble_sort2(alist):
# 外层循环控制比较几轮
n = len(alist)
for j in range(n - 1):
# 定义计数器
count = 0
# 内存循环控制交换
# -j是不再换已经排好的
for i in range(n - 1 - j):
# 若前一个比后一个大，则换
if alist[i] > alist[i + 1]:
alist[i], alist[i + 1] = alist[i + 1], alist[i]
# 计数器
count += 1
if count == 0:
return
if __name__ == '__main__':
li = [33, 11, 26, 78, 3, 9, 40]
print(li)
s1 = time.time()
for i in range(100000):
bubble_sort(li)
s2 = time.time()
print(li)
s3 = time.time()
for i in range(100000):
bubble_sort2(li)
s4 = time.time()
print("took {} s, {}s".format(s2-s1, s4-s3))
"""
洗牌思路：
循环已有牌的索引，将当前索引的牌与其他盘进行随机互换。
"""
cart_list = [i for i in range(1,55) if True]
def shuffle(carts):
"""
洗牌
:param carts: 已有牌
:return:
"""
for i in range(0, len(carts)):
rand_num = random.randint(i, len(carts)-1)
carts[i] , carts[rand_num] = carts[rand_num], carts[i]
shuffle(cart_list)
print(cart_list)
"""
选秀思路：
生成在权重总和范围内的随机数，判断属于哪一个权重，并返回该权重索引，由此计算出每一次选中的队伍。
"""
lis = ['太阳', '尼克斯', '篮网' '骑士', '湖人', '鹈鹕', '其他']
proportion = [25, 20, 15, 10, 10, 10, 10]
def weight_choice(weight):
"""
按权重筛选
:param weight:权重列表
:return: 选中的lis索引
"""
t = random.randint(0, int(sum(weight))-1)
for i, val in enumerate(weight):
t -= val
if t < 0:
return i
count = 0
for i in range(1000):
s = weight_choice(proportion)
if s == 0:
count += 1
print(count)