算法 時間復雜度, 空間復雜度, 冒泡排序**, 選擇排序, 插入算法, 快速排序**, 希爾算法，計數排序, 二分法查找**

 時間復雜度

 小結:

 

空間復雜度

 

算法可視化網站推薦

https://visualgo.net/zh

 

冒泡排序

 

### 冒泡排序 (************)
### 時間復雜度：最差的情況：O(n^2)  最好的情況：O(n)   空間復雜度:O(1)  並沒有開辟新的儲存空間
def bubble_sort(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

li = [7,5,4,6,3,8,2,9,1]
bubble_sort(li)
print(li)

 

選擇排序

### 選擇排序
### 時間復雜度是：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)):  ### i=2
        tmp = li[i] ## tmp=li[2]=4
        j = i - 1  ### j = 1 li[1]=7

        while j >= 0 and li[j] > tmp:
            li[j+1] = li[j]  ### [5,7,7,6,3,8,2,9,1]  ==> [5,5,7,6,3,8,2,9,1]
            j = j - 1   ### j = 0  j= -1

        li[j+1] = tmp

優化空間: 應用二分查找來尋找插入點

 

小結:

 

 

快速排序

# 快排
##### 時間復雜度是：O(nlogn)
def partition(li, left, right):  #### O(n)
    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)     #### O(logn)
        quick_sort(li, mid+1, right)

li = [7,5,4,6,3,8,2,9,1]
quick_sort(li,0,len(li)-1)
print(li)

 

上述4中方法時間比較

import time,random

start = time.time()
li = [random.randint(0,100000) for i in range(10000)]
bubble_sort(li)
print('bubble_sort:',time.time()-start) # 8.805101871490479

start = time.time()
li = [random.randint(0,100000) for i in range(10000)]
select_sort(li)
print('select_sort',time.time()-start)  # 4.129027366638184

start = time.time()
li = [random.randint(0,100000) for i in range(10000)]
insert_sort(li)
print('insert_sort',time.time()-start)  # 3.236048460006714

start = time.time()
li = [random.randint(0,100000) for i in range(10000)]
quick_sort(li,0,len(li)-1)
print('quick_sort',time.time()-start)   # 0.029005050659179688

 

希爾算法(了解)

 

 

 代碼：

 

 

小結：

 

 

計數排序(了解)

# 假如有一列數組為
# [7,5,4,6,3,8,2,9,1,9]    對他進行計數
# [0,1,1,1,1,1,1,1,1,2]    代表0有0個,1有1個,2有1個...9有2個  

# 計數排序
def count_sort(li):     # 因為時間復雜度沒有系數,所以整體復雜度算O(n)
    count = [0 for _ in range(10)]
    print(count)    # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

    for k in li:    # 此循環時間復雜度O(m)
        count[k] += 1
    print(count)    # [0, 1, 1, 1, 1, 1, 1, 1, 1, 2]

    li.clear()
    # 下面循環時間復雜度O(n)
    for k,v in enumerate(count):
        for i in range(v):  # 這層時間復雜度可以忽略不計
            li.append(k)

li = [5,7,4,6,3,8,2,9,1,9]
count_sort(li)
print(li)   # [1, 2, 3, 4, 5, 6, 7, 8, 9, 9]

 

算法拓展：

動態規划 貪心（分糖果，人民幣問題） 背包問題

力扣題：https://leetcode-cn.com/

 

二分法查找

 

 

##### 二分查找 時間復雜度O(logn)
def bin_search(li, value , low, high):

    if low<=high:
        mid = (low+high) // 2

        if li[mid] == value:
            return mid
        elif li[mid] > value:
            return bin_search(li, value, low, mid-1)
        else:
            return bin_search(li, value, mid+1, high)
    else:
        return

li = [1,2,3,4,5,6,7,8,9]
index = bin_search(li, 3, 0, len(li)-1)
print(index)