數據結構與算法(Python)

一.數據結構與算法概述

數據結構與算法的定義

咱們把現實中大量並且很是複雜的問題以特定的數據類型(個體)和特定的存儲結構(個體的關係)保存到相應的主存儲器(內存)中,以及在此基礎上爲實現某個功能而執行的相應操做,這個相應操做也叫作算法.

 

數據結構 = 個體 + 個體的關係

算法 = 對存儲數據的操做

二.衡量算法的標準

時間複雜度 指的是大概程序執行的次數,並不是程序執行的時間

空間複雜度 指的是程序執行過程當中,大概所佔有的最大內存

 

經常使用的查找

順序查找

lowB for循環

時間複雜度 O(n)

def linerSearch(li,val):
    for i in range(len(li)):
        if li[i] == val:
            return i

順序查找

二分查找

二分查詢的列表必須有序!

時間複雜度 O(logn)

# 遞歸
def binarySearch(li,low,high,val):
    if low < high:
        mid = (low+high) // 2
        if li[mid]==val:
            return mid
        elif li[mid]<val:
            binarySearch(li,mid+1,high,val)
        elif li[mid]>val:
            binarySearch(li,low,mid-1,val)
    else:
        return -1

# 循環
def binary_search(li,value):
    low = 0
    high = len(li)
    while low <= high:
        mid = (low+high)//2
        if li[mid] == value:
            return mid
        elif li[mid] > value:
            high = mid -1
        else:
            low = mid +1

二分查找

經常使用的幾個排序

冒泡排序

時間複雜度:O(n²⁾

def BubbleSort(li):
    for i in range(len(li)):
        flag = False
        for j in range(len(li)-i-1):
            if li[j]>li[j+1]:
                li[j],li[j+1] = li[j+1],li[j]
                flag = True
        if not flag:
            return li

冒泡排序

 

選擇排序

時間複雜度:O(n²⁾

 

def selectSort(li):
    for i in range(len(li)):
        for j in range(i+1,len(li)):
            if li[i] > li[j]:
                li[i],li[j] = li[j],li[i]
    print(li)

選擇排序

 

插入排序

時間複雜度:O(n²⁾

 

def insertSort(li):
    for i in range(1,len(li)):
        tmp = li[i]
        j = i - 1
        while j>=0 and li[j]>tmp:
            li[j+1] = li[j]
            j-=1
        li[j+1]=tmp
    print(li)

插入排序

 

快速排序

時間複雜度:O(nlogn⁾

 

# 一次調整
def partition(li,left,right):
    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+=1
        li[right] = li[left]
    li[left] = tmp
    return left

# 快速排序
def quickSort(li,left,right):
    if left < right:
        mid = partition(li, left, right)  ### O(n)
        quickSort(li, left, mid - 1)     ### O(logn)
        quickSort(li, mid + 1, right)

快速排序

 

歸併排序

時間複雜度:O(nlogn⁾

 

# 一次歸併
def merge(li,low,mid,right):
    i = low
    j = mid +1
    ltmp = []
    while i <= mid and j <=right:
        if li[i] <li[j]:
            ltmp.append(li[i])
            i = i + 1
        else:
            ltmp.append(li[j])
            j = j + 1
    while i <= mid:
        ltmp.append(li[i])
        i = i + 1
    while j <= right:
        ltmp.append(li[j])
        j = j + 1
    li[low:right + 1] =ltmp


def mergeSort(li, low, high):
    if low < high:
        mid = (low + high) // 2
        mergeSort(li, low, mid)
        mergeSort(li, mid + 1, high)
        print('歸併以前:', li[low:high+1])
        merge(li, low, mid, high)
        print('歸併以後:', li[low:high + 1])

歸併排序

希爾排序

時間複雜度:O(nlogn⁾

 

def shell_sort(li):
    gap = len(li)//2
    while gap > 0 :
        for i in range(gap,len(li)):
            tmp = li[i]
            j = i -gap
            while j>=0 and tmp <li[j]:
                li[j + gap ] = li[j]
                j -= gap
            li[j + gap] = tmp
        gap //= 2

希爾排序

 

計數排序

時間複雜度:O(nlogn⁾

def countSort(li):
    li_new=[]
    count = [0 for i in range(len(li))]
    for i in li:
        count[i]+=1

    for index,val in enumerate(count):
        print(index,val)
        for i in range(val):
            li_new.append(index)
    print(li_new)

計數排序

排序小結

排序方法	時間複雜度			穩定性	代碼複雜度
	最壞狀況	平均狀況	最好狀況
冒泡排序	O(n2)	O(n2)	O(n)	穩定	簡單
直接選擇排序	O(n2)	O(n2)	O(n2)	不穩定	簡單
直接插入排序	O(n2)	O(n2)	O(n2)	穩定	簡單
快速排序	O(n2)	O(nlogn)	O(nlogn)	不穩定	較複雜
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	不穩定	複雜
歸併排序	O(nlogn)	O(nlogn)	O(nlogn)	穩定	較複雜
希爾排序		O(1.3n)		不穩定	較複雜

三.數組與鏈表