排序算法

排序算法的稳定性：让原本相等的键值维持的纪录维持相对次序

冒泡排序（BUbble Sort）

从头往后走，每次比较相邻的两个数字，一次循环将最大（最小）的数字放在最后，经过n-1次冒泡完成排序。

冒泡：每次将最大的值往后移到相应的位置（第一次最大，第二次次大，依次往后）

#关键代码
for i in range(n-1):
    flag = 0
    for j in range(n-1-j):
        if bubble[j] > bubble[j+1]:
            bubble[j], bubble[j+1] = bubble[j+1], bubble[j]
            flag = 1
    if flag == 0: #该序列不需要进行排序
        return bubble

时间复杂度：O(n2)

稳定性：稳定

选择排序

从未排序的序列中选择一个次小的让前面去放

#关键代码
n = len(alist)
for j in range(n-1):
    min_index = j
    for i in range(j+1, n):
        if alist[min_index] > alist[i]:
            min_index = i
    alist[j], alist[min_index] = alist[min_index], alist[j]

时间复杂度：O(n2)

稳定性：不稳定

插入算法

把后面序列的数字插入到前面序列合适的位置

#关键代码
for i in range(1, n):
    while i > 0:
        if alist[i] < alist[i-1]:
            alist[i], alist[i-1] = alist[i-1], alist[i]
            i -= 1
        else:
            break

时间复杂度：O(n2)

稳定性：稳定

希尔排序

对插入算法的改进。其基本思想是：先比较距离远的元素，而不是像简单交换排序算法那样先比较相邻的元素，这样可以快速减少大量的无序情况，从而减轻后续的工作。被比较的元素之间的距离逐步减少，直到减少为1，这时的排序变成了相邻元素的互换。

#关键代码实现
def shell_sort(alist):
"""希尔排序"""
n = len(alist)
gap = n//2

while gap > 0:
    for j in range(gap, n):
        i = j
        while i > 0:
            if alist[i] < alist[i-gap]:
                alist[i], alist[i-gap] = alist[i-gap], alist[i]
                i -= gap
            else:
                break
    gap //= 2

最坏时间复杂度：O(n2)

稳定性：不稳定

快速排序

基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

#关键代码
def quick_sort(alist, first, last):
    if first == last:
        return 
    mid_value = alist[0]
    low = firsst
    high = last
    
    while low < high:
        #high左移
        while low < high and alist[high] >= mid_value:
            high -= 1
        alist[low] = alist[high]
        
        while low < high and alist[low] < mid_value:
            low += 1
        alist[high] = alist[low]
    #从循环退出，low==high    
    alist[low] = mid_value
    
    #对low左边进行快速排序
    quick_sort(alist, first, low-1)
    #对low右边的列表进行快速排序
    quick_sort(alist, low+1, last)

最优时间复杂度： O(nlogn) (经过多少次对半折分可以拆到1,nlog2n)

最坏时间复杂度：O(n2)

稳定性：不稳定

归并算法

基本思想：先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，即二路归并

#关键代码
def merge_sort(alist):
    """归并排序"""
    n = len(alist)
    if n <= 1
        return alist
    mid == n//2
        
    # left采用归并排序后形成的有序的新的列表
    left_li = merge_sort(alist[:mid])
    
    # right采用归并排序后形成的有序的新的列表
    right_li = merge_sort(alist[mid:])
    
    left_pointer, right_pointer = 0, 0
    result = []
    
    while left_pointer < len(left_li) and right_pointer < len(right_li):
        if left_li[left_pointer] <= right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer += 1
        elif: 
        result.append(right_li[right_pointer])
        right_pointer += 1
    
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result

最优时间复杂度：O(nlogn) (理解：纵向是logn级序列拆分，横向进行n次比较)

最坏时间复杂度：O(nlogn)

稳定性：稳定

时间上是最小的，但是空间上，需要额外的开销，前面的算法是在原有的列表上进行排序的。

搜索算法——二分查找

二分查找，又称为折半查找。查找对象：有序的顺序表。

def binary_search(alist, item):
    """二分查找"""
    n = len(alist)
    if n > 0:
        mid = n//2
        if alist[mid] == item:
            return True
        elif item < alist[mid]:
            return binary_search(alist[:mid], item)
        else:
            return binary_search(alist[mid:], item)
    return False
    
# 非递归
def binary_search(alist, item):
    """二分查找，非递归"""
    n = len(alist)
    first = 0
    last = n-1
    while first <= last:
        mid = (first + last)//2
        if alist[mid] == item:
            return True
        elif alist[mid] > item:
            last = mid -1
        else:
            first = mid + 1
    return False

最坏时间复杂度：O(logn) (普通遍历查找时间复杂度是O(n))

最优时间复杂度：O(1)