排序算法的實現:冒泡排序、選擇排序、快速排序、二分查找、快速排序

冒泡排序：

1. 比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。
2. 對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。這步作完後，最後的元素會是最大的數。
3. 針對全部的元素重複以上的步驟，除了最後一個。
4. 持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。

def bubble_sort(bubbers):
    """
    冒泡排序，將numbers按從小到大排序
    :param numbers: list類型
    :return: list類型
    """
    for i in range(len(bubbers)-1,0,-1):
        for j in range(0,i):
            if bubbers[j] > bubbers[j+1]:
                bubbers[j],bubbers[j+1] = bubbers[j+1],bubbers[j]

    return bubbers

 選擇排序：

def select_sort(a):
    """
    選擇排序：每一次從待排序的數據元素中選出最小（或最大）的一個元素，
    存放在序列的起始位置，直到所有待排序的數據元素排完。
    :param selects:list類型
    :return:
    """
    for i in range(0,len(a)-1,1):
        k = i
        for j in range(i+1,len(a)):
            if a[k] > a[j]:
                k = j
        if k != i:
            a[i], a[k] = a[k], a[i]

    return a

 快速排序：

1. 從第一個元素開始，該元素能夠認爲已經被排序
2. 取出下一個元素，在已經排序的元素序列中從後向前掃描
3. 若是該元素（已排序）大於新元素，將該元素移到下一位置
4. 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置
5. 將新元素插入到該位置後
6. 重複步驟2~5

def insert_sort(b):
    for i in range(1,len(b)-1,1):
        for j in range(i,0,-1):
            if b[j-1]> b[j]:
                b[j-1],b[j] = b[j],b[j-1]
    return b

 二分查找：

def binary_search(c,key):
    """
    從數組的中間元素開始，若是中間元素正好是要查找的元素，則搜索過程結束；
    若是某一特定元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半中查找。
    若是在某一步驟數組爲空，則表明找不到。
    :param c:
    :param key:
    :return:
    """
    left = 0
    right = len(c)-1
    while left <= right:
        mid = (left + right) / 2
        if c[mid] < key:
            left = mid +1
        elif c[mid] > key:
            right = mid -1
        else:
            return mid

 快速排序：（分治法）

1．先從數列中取出一個數做爲基準數。

2．分區過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊。

3．再對左右區間重複第二步，直到各區間只有一個數。

def qiuckly_sort(array):
    assert isinstance(array, list)
    if len(array) == 0:
        return array

    quick_sort(array, 0, len(array)-1)
    return array

def quick_sort(array, left, right):

    if left < right:
        pivot = array[left]
        i, j = left, right
        while i < j:
            while i < j and array[j] >= pivot:
                    j -= 1
            if i < j:
                    array[i] = array[j]
                    i += 1
            while i < j and array[i] < pivot:
                    i += 1
            if i < j:
                    array[j] = array[i]
                    j -= 1
            array[i] = pivot
            quick_sort(array, left, i)
            quick_sort(array, i + 1, right)

if __name__ == '__main__':
    a = [5, 3, 7, 2, 8, 4]
    qiuckly_sort(a)
    quick_sort(a,0,len(a)-1)
    print a

方法二：

1.取第一個數爲基準數

2.遍歷list，小於基準數+基準數+大於基準數

def qsort(arr):

    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        return qsort([x for x in arr[1:] if x < pivot]) + \
               [pivot] + \
               qsort([x for x in arr[1:] if x >= pivot])