经典算法

冒泡排序

冒泡排序（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]