几个算法

 

# 冒泡排序

# 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)