数据结构——排序算法列举

排序与搜索
排序算法（Sorting algorithm）是一种能将一串数据依照特定顺序进行排列的一种算法。

排序算法的稳定性
稳定性：稳定的排序算法会让原本有相等键值的记录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的记录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。

常见的排序算法实现：

冒泡排序：

# coding : utf-8


def bubble_sort(alist):
    ''' 冒泡排序'''
    n = len(alist)
    # 一共要经历多少次"游标从头走到尾"过程
    for j in range(n-1):
        # 游标从头走到尾
        count = 0 #每次游标从头走到尾，元素交换次数
        for i in range(n-1-j):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1]  = alist[i+1], alist[i]
                count += 1
        if count == 0: # 如果元素交换次数为0，意味着列表中元素已经是有序的，则无需继续往下执行循环，直接返回当前结果即可
            return



if __name__ == '__main__':
    li = [54, 26, 93, 17, 77 ,31, 44, 55, 20]
    print(li)
    bubble_sort(li)
    print(li)

时间复杂度：
最优时间复杂度：O(n) (表示遍历一次并没有发现可以交换的元素，排序结束)
最坏时间复杂度：O(n*n)

稳定性：稳定

选择排序：

def select_sort(alist):
    '''选择排序'''
    n = len(alist)
    # 共有n-1次遍历过程
    for j in range(n-1):
        min_index = j
        #遍历元素，找到最小值索引，放到本次遍历范围首位置
        for i in range(j + 1, n):
            if alist[i] < alist[min_index]:
                min_index = i # 当前min_index为本次比遍历最小值索引
        alist[j], alist[min_index] = alist[min_index], alist[j]

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77 ,31, 44, 55, 20]
    print(li)
    select_sort(li)
    print(li)

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

稳定性：不稳定（考虑升序每次选择最大值并放在最后面的情况）

插入排序：

def insert_sort(alist):
    '''插入排序'''
    n = len(alist)
    #从右边的无序序列中取出多少个元素执行这样的过程
    for j in range(1, n):
        i = j
        #执行从右边的无序序列中取出第一个元素，即i位置元素，然后将7其插入到前面的正序序列中
        while i > 0:
            if alist[i] < alist[i - 1]:
                alist[i], alist[i - 1] = alist[i - 1],  alist[i]
                i -= 1
            #优化算法，如果当前元素比左边有序序列中最后一个元素都大，那么不用继续比较，直接退出
            else:
                break


if __name__ == '__main__':
    li = [54, 26, 93, 17, 77 ,31, 44, 55, 20]
    print(li)
    insert_sort(li)
    print(li)

时间复杂度：
最优时间复杂度：O(n)
最坏时间复杂度：O(n**2)

稳定性：稳定

希尔排序：

def shell_sort(alist):
    '''希尔排序'''
    n = len(alist)
    gap = n // 2
    # gap变化到0之前，插入算法执行次数
    while gap > 0:
        # 也属于插入算法， 与普通的插入算法的区别就是gap步长
        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步长
        gap //= 2


if __name__ == '__main__':
    li = [54, 26, 93, 17, 77 ,31, 44, 55, 20]
    print(li)
    shell_sort(li)
    print(li)

时间复杂度：
最优时间复杂度：根据步长序列的不同而不同
最坏时间复杂度：O(n**2)

稳定性：不稳定

快速排序：

def quick_sort(alist, first, last):
    '''
    快速排序
    first: 进行快速排序的序列的第一个位置索引
    last: 进行快速排序的序列的最后一个位置索引
    '''
    if first >= last:
        return
    mid_value = alist[first]
    low = first
    high = last
    # 当low和high游标没重合时候继续移动
    while low < high:
        # high左移
        while low < high and alist[high] >= mid_value:
            high -= 1
        alist[low] = alist[high]

        # low右移
        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)


if __name__ == '__main__':
    li = [54, 26, 93, 17, 77 ,31, 44, 55, 20]
    print(li)
    quick_sort(li, 0, len(li)-1)
    print(li)

时间复杂度：
最优时间复杂度：O(n*logn)
最坏时间复杂度：O(n**2)

稳定性：不稳定

二分法查找

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+1:], item)
        return  False