算法分類 ,時間複雜度 ,空間複雜度,優化算法

算法

　　　　今天給你們帶來一篇關於算法排序的分類,算法的時間複雜度,空間複雜度,還有怎麼去優化算法的文章,喜歡的話,能夠關注,有什麼問題,能夠評論區提問,能夠與我私信,有什麼好的意見,歡迎提出.

前言: 算法的複雜度分爲時間複雜度與空間複雜度,時間複雜度指執行算法須要須要的計算工做量,空間複雜度值執行算法須要的內存量,可能在運行一些小數據的時候,你們體會不到算法的時間與空間帶來的體驗. 優化算法就是將算法的時間優化到最快,將空間優化到最小,假如你寫的mod可以將百度遊覽器的搜索時間提高0.5秒,那都是特別厲害的成績.

 

本章內容:   1,算法有哪些   2,時間複雜度,空間複雜度   3,優化算法   4,算法實例

一,算法有哪些

　　常見的算法有冒泡排序,快排,歸併,希爾,插入,二分法,選擇排序,廣度優先搜索,貪婪算法,這些都是新手入門必需要了解的,你能夠不會,可是你必需要知道他是怎麼作到的,原理是什麼,今天就給你們講一講咱們經常使用的冒泡排序,選擇排序,這兩個排序算法,

 

 

1,冒泡排序(Bubble Sort), 爲何叫他冒泡排序呢? 由於他就像是從海底往海面升起的氣泡同樣,從小到大,將要排序的數從小到大排序,

冒泡的原理: 他會一次比較兩個數字,若是他們的順序錯誤,就將其調換位置,若是排序正確的話,就比較下一個,而後重複的進行,直到比較完畢,

這個算法的名字也是這樣由來的,越大的數字,就會慢慢的'浮'到最頂端. 好了該上代碼了,下面就是冒泡排序的代碼,冒泡相對於其餘的排序算法來講,比較的簡單,比較好理解,運算起來也是比較迅速的,比較穩定,在工做中也會常常用到,推薦使用

 

# 冒泡排序
def bubble_sort(alist):
    n = len(alist)
    # 循環遍歷，找到當前列表中最大的數值
    for i in range(n-1):
        # 遍歷無序序列
        for j in range(n-1-i):
            # 判斷當前節點是否大於後續節點，若是大於後續節點則對調
            if alist[j] > alist[j+1]:
                alist[j], alist[j+1] = alist[j+1], alist[j]
if __name__ == '__main__':
    alist = [12,34,21,56,78,90,87,65,43,21]
    bubble_sort(alist)
    print(alist)
# 最壞時間複雜度: O(n^2)
# 最優時間複雜度: O(n)
# # 算法穩定性:穩定

 　　

 

2,選擇排序(selection sort)

　　　　選擇排序(selection sort)是一種簡單直觀的排序方法, 他的原理是在要排序的數列中找到最 大 或者最 小 的 元素,放在列表的起始位置,而後從其餘裏找到第二大,而後第三大,依次排序,

依次類,直到排完,

　　　　選擇排序的優勢是數據移動, 在排序中,每一個元素交換時,至少有一個元素移動,所以N個元素進行排序,就會移動 1--N 次,在全部依靠移動元素來排序的算法中,選擇排序是比較優秀的一種

 

選擇排序時間複雜度與穩定性:

最優時間複雜度: O(n2)

最壞時間複雜度:O(n2)

算法穩定性 :不穩定(考慮每次升序選擇最大的時候)

#             if alist[j] < alist[min_index]:
#                 min_index = j
#
#         # 判斷min_index索引是否相同,不相同，作數值交換
#         if i != min_index:
#             alist[i],alist[min_index] = alist[min_index],alist[i]
#
#
# if __name__ == '__main__':
#     alist = [12,34,56,78,90,87,65,43,21]
#     # alist = [1,2,3,4,5,6,7,8,9]
#     select_sort(alist)
#     print(alist)

# O(n^2)
# 不穩定


def select_sort(alist):
    """選擇排序"""
    n = len(alist)
    for i in range(n - 1):
        min_index = i  # 最小值位置索引、下標
        for j in range(i+1, n):
            if  alist[j] < alist[min_index]:
                min_index = j
        # 判斷min_index ,若是和初始值不相同，做數值交換
        if min_index != i:
            alist[i], alist[min_index] = alist[min_index],alist[i]


if __name__ == '__main__':
    alist = [8,10,15,30,25,90,66,2,999]
    select_sort(alist)
    print(alist)

 

 這是一些算法的時間複雜度與穩定性

　　　　

時間複雜度,空間複雜度

 

　　　　接下來就要來講說時間複雜度與空間複雜度: 時間複雜度就是假如你 泡茶,從開始泡,到你喝完茶,一共用了多長時間,你中間要執行不少步驟,取茶葉,燒水,上廁所,接電話,這些都是要花時間的,

在算法中,時間複雜度分爲  O(1)最快 , O(nn)最慢,

O(1) < O(logn) <O(n)<O(n2)<O(n3)<O(2n) <O(nn)    通常遊覽器的速度都在O(n),作咱們這一行,要注意客戶體驗,若是你程序的運行特別慢,估計別人來一次,之後不再會來了      

 

 

下面給你們找了張如何計算 時間複雜度的圖片:

 

 

 

　　　　空間複雜度(space complexity) ,執行時所須要佔的儲存空間,記作 s(n)=O(f(n)),其中n是爲算法的大小, 空間複雜度 絕對是效率的殺手,曾經看過一遍用插入算法的代碼,來解釋空間複雜度的,

以爲特別厲害,我就比較low了,只能給你們簡單的總結一下我遇到的空間複雜度了,

　　通常來講,算法的空間複雜度值得是輔助空間,好比:一組數字,時間複雜度O(n),二維數組a[n][m]   :那麼他的空間複雜度就是O(n*m)     ,由於變量的內存是自動分配的,第一個的定義是循環裏面的,因此是n*O(1)   ,若是第二個循環在外邊,那麼就是1*O(1)     ,這裏也只是一個瞭解性的東西,若是你的工做中不多用到,那麼沒有必要深究,由於用的真的不多

 

 

 

優化算法

 

這邊帶來了代碼,大家在複製下來了python上運行一下,看一下用的時間與不一樣, 天然就懂了,

這是未優化的算法  

 

''
已知有a,b,c三個數,都是0-1000以內的數,
且: a+b+c=1000 並且 a**2+b**2=c**2  ,求a,b,c一共有多少種組合
'''
# 在這裏加一個時間模塊,待會好計算出結果
import time
# 記錄開頭時間
start_time=time.time()
# 把a,b,c循環出來
for  a in range(1001):
    for b in range(1001):
        for c in range(100):
            #  判斷他  主公式  第一次,並未優化
            if a+b+c==1000 and a**2 + b**2 == c**2 :
                # 打印
                print("a=" ,a)
                print("b=" ,b)
                print("c=" ,c)
            else:
                pass
stop_time = time.time()
print('一共耗時: %f'%(stop_time-start_time))
# 一共耗時 156.875001秒

 

 

 

這是第一次優化

import time
# 記錄開頭時間
start_time=time.time()
# 把a,b,c循環出來
for  a in range(1001):
    # 這裏改爲1001-a以後,他就不用再循環b了
    for b in range(1001-a):
        for c in range(100):
            #  判斷他  主公式  第二次,優化了b,
            if a+b+c==1000 and a**2 + b**2 == c**2 :
                print("a=" ,a)
                print("b=" ,b)
                print("c=" ,c)
            else:
                pass
stop_time = time.time()
print('一共耗時: %f'%(stop_time-start_time))
# 一共耗時 50.557070秒

 

最後一次優化

import time
# 記錄開頭時間
start_time=time.time()
# 把a,b,c循環出來
for  a in range(1001):
    for b in range(1001-a):
            c=1000 - a - b
            #  判斷他  主公式  第三次,優化了b和c
            if a+b+c==1000 and a**2 + b**2 == c**2 :
                print("a=" ,a)
                print("b=" ,b)
                print("c=" ,c)
            else:
                pass
stop_time = time.time()
print('一共耗時: %f'%(stop_time-start_time))
# 一共耗時 2.551449秒

 

從156秒優化到l2秒,    基本運算總數 * 基本運算耗時  = 運算時間    這之間的耗時和你的機器有着很大的關係

 

今天是12月30日,明天就要跨年了,祝你們2019年事業有成,工資直線上升,早日脫單,