幾個算法

 

# 冒泡排序

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