1.選擇排序
     給定一個列表,一趟遍歷記錄最小的數，放到第一個位置，再一趟遍歷記錄剩餘列表中最小的數，繼續放置……
    1.每趟選出一個最小的，得到其索引，然後把該值和該趟的起始值作交換
    該趟最小值在確定的位置，每趟比上一趟比較的資料少一個，資料從前減少
    2.每趟的起始值編號比上一趟的起始值多一，起始編號最大到倒數第二個
    3.直到倒數第二個與倒數第一個比較結束後，程式結束，共進行n-1趟

lwst = [4,3,5,2,1,0,8]

def choose_sort(list):
	i = 0
	while i <len(lwst) - 1:
		min = i
		j = i + 1
		while j <len(lwst):
			if lwst[j] < lwst[min]:
				min = j  # 找到最小值的編號
			j += 1
		if min != i:
			lwst[min],lwst[i] = lwst[i],lwst[min]  # 將起始值與最小編號值交換
		i += 1

choose_sort(lwst)
print(lwst)  # [0, 1, 2, 3, 4, 5, 8]
 

def choose_sort(list):
    for i in range(len(list)):
        min = i
        for j in range (i+1 ,len(list)):
            if list[j] < list[min]:
                min = j
        if min != i:
            list[i],list[min] = list[min],list[i]

    直接選擇排序時間複雜度 O(n^2)

2.氣泡排序
        給定一個列表，列表每兩個相鄰的數，如果前邊的比後邊的大，那麼交換這兩個數！
        1.每趟挑出一個最大的值，每趟結束後會有一個數據在確定的位置，即該趟最後一位
        2.每趟資料都會減少一個，資料從後減少
        2.首先將第二個與第一個資料進行比較，直到倒數第一個與倒數第二個比較，程式結束，共進行n-1趟

#  新增裝飾器，計算排序所花費的時間


def cal_time(func):
    def wrapper(*args,**kwargs):
        t1 = time.time()
        result = func(*args, **kwargs)
        t2 = time.time()
        print("%s running time: %s secs." %(func.__name__,t2 - t1))
        return result
    return wrapper

@cal_time
def bubble_sort(list):
	n = len(list)
	while n > 1:
		exchange = False  # 新增 是否交換標記
		i = 1
		while i < n:
			if list[i] < list[i-1]:
				list[i],list[i-1] = list[i-1],list[i]  # 直接交換資料
				exchange = True  # 代表該趟發生交換
			i += 1
		if not exchange:  # 若該趟未發生交換，則表明資料已經有序，停止排序
			break
		n -= 1
bubble_sort(lwst)
print(lwst)		
 

def bubble_sort(list):
    for i in range(len(list) - 1):
        swap = False
        for j in range(len(list) - 1 - i):
            if list[j] > list[j+1]:
                list[j],list[j+1] = list[j+1],list[j]
                swap = True
        if not swap:
            return

       建立無序的列表序列，可以通過random模組的shuffle方法

import random
data = list(range(1000)
random.shuffle(data)

        冒泡時間複雜度 O(n^2) , 最好情況O(n)

3.插入排序
        給定一個列表，列表被分為有序區和無序區兩個部分，最初有序區只有一個元素，每次從無序區選擇一個元素，插入到有序         區的位置，直到無序區變空
        1.在最終順序確定前 無法確定資料的位置
        2.先將第一趟第一個值作為其實值，且是最小值
        3.每趟一個新的起始值,先將這個起始值儲存在一個變數裡
        4.起始值與其前一個數據比較若不交換則本趟結束，開始下一趟
        若發生交換，則再繼續向前比較，直到本趟結束
        5.直到最後一個數據參與比較，程式結束，共進行n-1趟

def insert_sort(list):
	i = 1
	while i < len(list):
		j = i-1
		insert = list[i]  # 儲存已有資料
		while j >= 0:
			if list[j] > insert:
				list[j+1] = list[j]  # 將大資料後移一位
				j -= 1
			else:
				break
		list[j+1] = insert  # 將已有資料放入空位
		i += 1
insert_sort(lwst)
print(lwst)

def insert_sort(list):
    for i in range(1,len(list) ):
        item = list[i]
        j = i -1
        while j >= 0 and item < list[j]:
            list[j+1] = list[j]
            j -= 1
        list[j+1] = item

    插入排序時間複雜度 O(n^2)