算法和算法復雜度


算法衡量指標:正確性,可讀性,易維護性,運行時間
算法計算時間可以通過復雜度的階表示:對數階( log 2 x ),線性階(x),多項式階( x 2 ),指數階( 2 x
大O表示法,表示在。。。。。階,線性時間算法的階為:O(n)

#找出一個列表中最小值的索引
def index_of_min(shuffle_list):
    index_min = 0
    for i in range(len(shuffle_list)):
        if shuffle_list[i] < shuffle_list[index_min]:
            index_min = i
    return index_min

index_of_min([3,6,1,4,5])#算法必須經過n-1次比較,復雜度為O(n)

#numpy中函數實現找出列表中最小值的索引
import numpy as np
np.argmin([3,6,1,4,5])

實現一個順序搜索算法,判斷一個數是否在指定的無序列表中

def order_search(target,lst):
    for i in lst:
        if i == target:
            return True
    return False

order_search(3,[4,5,6,7])#算法最少判斷一次,最多要判斷n次,算法復雜度為O(n)

實現一個二叉樹算法,判斷一個數是否在指定的有序列表中

def binary_search(target,ordered_lst):
    left = 0
    right = len(ordered_lst) - 1
    while left <= right:
        center = (left + right) // 2
        if target == ordered_lst[center]:
            return True
        else:
            if target < ordered_lst[center]:
                right = center - 1
            else:
                left = center + 1
    return False  

binary_search(300,[3,5,6,7,9,10,12,18,30])

二叉樹搜索算法最少執行一次,做多執行k次,使得 n / 2 k = 1 ,所以算法復雜度為:O( log 2 n )。
可以發現二叉樹搜索算法比順序搜索算法更高效,但是前提是列表必須是有序的。

一個類對象如果能夠識別比較運算符,比如==,<,>那類中需要定義下面的魔法方法:

__eq__,__lt__,__gt__
#實現能一個進行比較操作的類
class compare_operation():
'''該類實現比較操作'''
    def __init__(self,data):
        self.data = data
    def __eq__(self,other):
        return self.data == other.data
    def __lt__(self,other):
        return self.data < other.data
    def __gt__(self,other):
        return self.data > other.data
a = compare_operation(4)
b = compare_operation(5)

用選擇排序算法對列表排序,算法思路:從第一個位置開始,先找到列表中最小項,如果該項不是第一的位置,就交換着兩個位置。接着重從第二個位置開始,重復上面的步驟,直到算法達到列表的最后一個位置。

def seleclt_sorted(shuffled_lst):
    index_location = 0#算法開始的位置
    while index_location < len(shuffled_lst) - 1:#從第一個位置開始循環
        min_index = index_location
        index = index_location + 1
        while index < len(shuffled_lst):#從算法開始位置,找出列表中的最小值
            if shuffled_lst[min_index] > shuffled_lst[index]:
                min_index = index
            index += 1
        shuffled_lst[index_location],shuffled_lst[min_index] = shuffled_lst[min_index],shuffled_lst[index_location]#最小值和算法開始位置值交換
        index_location += 1#后面循環起始位置加1
    return shuffled_lst

選擇排序算法總的循環次數為:n-1 + n-2 + n-3 +……+1,也就是 1 2 n 2 1 2 n ,算法復雜度為O( n 2 )

冒泡排序對無序列表排序,算法思路:從列表頭部開始,兩兩比較,數據大的就交換位置,以冒泡的方式將最大項排到列表最后

def bubble_sorted(shuffled_lst):
    for i in range(len(shuffled_lst)):
        for j in range(i+1,len(shuffled_lst)):
            if shuffled_lst[i] > shuffled_lst[j]:
                shuffled_lst[i],shuffled_lst[j] = shuffled_lst[j],shuffled_lst[i]
    return shuffled_lst

冒泡算法和選擇排序算法循環次數一樣,算法復雜度為O( n 2 )

插入排序法,算法思路:類似排撲克牌,拿到第i張牌,與前i-1比較,插到合適的位置

def insection_sorted(shuffled_lst):
    i = 1#第一個要插入的值
    while i < len(shuffled_lst):
        insert_value = shuffled_lst[i]
        j = i -1
        while j >= 0:
            if insert_value < shuffled_lst[j]:
                shuffled_lst[j+1] = shuffled_lst[j]#如果當前值比要插入的值要大,就后移一位
                j -= 1
            else:
                break #前i-1個值都是已經排序的好的,所以循環到大於的情況就可以停止了
        shuffled_lst[j+1] = insert_value#插入值
        i += 1#插入的值的索引自增
    return shuffled_lst

插入算法外部循環n-1,內部循環在所有數據都是沒排序時候,外部循環第一次循環,內不循環一次,第2次循環,內部循環2次,所以總次數為 1 2 n 2 1 2 n 2 ,算法復雜度為:O( n 2 )

快排算法,算法思路:列表中選一個點做為基准點(一般可以選第一個元素),將列表中其他與該基准點比較,小的放在左邊,大的放在右邊,最后對分好的左右子列表重復遞歸使用該過程。遇到少於兩個元素的子列表就結束該過程。

#快排實現
def sort_partion(shuffled_list,left,right):
    pivot_index = left
    pivot = shuffled_list[left]
    for i in range(left+1,right+1):
        if shuffled_list[i] < pivot:#遍歷列表開始判斷該數是否小於基數
            pivot_index += 1
            if pivot_index != i:
                shuffled_list[pivot_index],shuffled_list[i] = shuffled_list[i],shuffled_list[pivot_index]
    shuffled_list[left],shuffled_list[pivot_index] = shuffled_list[pivot_index],shuffled_list[left]
    return pivot_index 
def quick_sort(shuffled_list,left,right):
    if left < right:
        pivot_index = sort_partion(shuffled_list,left,right)
        quick_sort(shuffled_list,left,pivot_index-1)
        quick_sort(shuffled_list,pivot_index+1,right)
    return shuffled_list

注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
  © 2014-2022 ITdaan.com