經典算法

冒泡排序

冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，若是他們的順序錯誤就把他們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢"浮"到數列的頂端。


def bubbleSort(nums):
    for i in range(len(nums) - 1):
        for j in range(len(nums) - i - 1):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
                # temp = nums[j]
                # nums[j] = nums[j + 1]
                # nums[j + 1] = temp
    return nums

nums = [3, 4, 2, 22, 7, 8]
# print(bubbleSort(nums))

二分查找

二分搜索是一種在有序數組中查找某一特定元素的搜索算法。搜索過程從數組的中間元素開始，若是中間元素正好是要查找的元素，則搜索過程結束；若是某一特定元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半中查找，並且跟開始同樣從中間元素開始比較。若是在某一步驟數組爲空，則表明找不到。這種搜索算法每一次比較都使搜索範圍縮小一半。

def binarySearch(arr, l, r, x):
    if r > l:
        # print(r - l,"--",l + (r - l),'--',l + (r - l) / 2)
        mid = int(l + (r - l) / 2)
        if arr[mid] == x:
            return mid
        elif arr[mid] > x:
            print('mid-1',mid - 1)
            return binarySearch(arr, mid - 1, r, x)
        else:
            print('mid+1', mid + 1)
            return binarySearch(arr, mid + 1, r, x)
    else:
        return -1

arr = [2, 3, 4, 10, 40]
x = 10
# print(binarySearch(arr, 0, len(arr) - 1, x))

 

線性查找

線性查找指按必定的順序檢查數組中每個元素，直到找到所要尋找的特定值爲止。

def search(arr,n,x):
    for i in range(0,n):
        if arr[i]  == x:
            return i
arr = [ 'A', 'B', 'C', 'D', 'E' ];
# print(search(arr, len(arr),"D") )

 

插入排序

插入排序（英語：Insertion Sort）是一種簡單直觀的排序算法。它的工做原理是經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。


def insertionSort(arr):
    for i in range(1,len(arr)):
        key = arr[i]
        j = i -1
        # print(key,j)
        while j>=0 and key  < arr[j]:
            arr[j+1] = arr[j]
            j -=1
            # print(arr,key)
        arr[j+1] = key
    return arr
arr = [12, 11, 13, 5, 6]
# print(insertionSort(arr))

 

快速排序

快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分爲較小和較大的2個子序列，而後遞歸地排序兩個子序列。

在數列之中，選擇一個元素做爲」基準」（pivot），或者叫比較值。

數列中全部元素都和這個基準值進行比較，若是比基準值小就移到基準值的左邊，若是比基準值大就移到基準值的右邊

以基準值左右兩邊的子列做爲新數列，不斷重複第一步和第二步，直到全部子集只剩下一個元素爲止。



def quickSort(arr):
    if len(arr) <2:
        return arr
    # 選取基準，隨便選哪一個均可以，選中間的便於理解
    mid = arr[len(arr)//2]
    left,right = [],[]
    arr.remove(mid)
    for i in arr:
        # print(i,'--i--',mid)
        if i >=mid:
            right.append(i)
        else:
            left.append(i)
    # print(left,right)
    return quickSort(left) +[mid]+quickSort(right)
arr = [10, 7, 8, 9, 1, 5]
# print(quickSort(arr) )

選擇排序

選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工做原理以下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而後，再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。以此類推，直到全部元素均排序完畢。

def SelectionSort(arr):

    for i in range(len(arr)):
        min_idx = i
        print(min_idx)
        for j in range(i+1,len(arr)):
            if arr[min_idx] >arr[j]:
                min_idx = j
        arr[i],arr[min_idx] = arr[min_idx],arr[i]
    return arr

arr  = [64, 25, 12, 22, 11]
# print(SelectionSort(arr))

希爾排序

希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序算法。

希爾排序的基本思想是：先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄"基本有序"時，再對全體記錄進行依次直接插入排序。

def shellSort(arr):
    n = len(arr)
    gap = int(n/2)
    while gap >0:
        for i in range(gap,n):
            temp = arr[i]
            j = i
            while j>=gap and arr[j-gap] >temp:
                arr[j] = arr[j-gap]
                j-=gap
            arr[j] = temp
        gap = int(gap / 2 )
    return arr
arr = [ 12, 34, 54, 2, 3]