python100天之数据结构与算法

渐进时间复杂度大O标记：

1、O(C)：常量时间复杂度-哈希存储/布隆过滤器；

2、O（logN）：对数时间复杂度-折半查找（二分查找）；

3、O（n）：线性时间复杂度-顺序查找/计数排序；

4、O(nlogN)：线性对数时间复杂度-归并排序/快速排序；

5、O(n^2)：平方时间复杂度-简单排序算法（冒泡排序、插入排序、选择排序）；

6、O(n^3)：立方时间复杂度-Floyd算法、矩阵乘法运算；

7、O(2^n)：几何级数时间复杂度-汉诺塔

8、O(N!)：阶乘时间复杂度-旅行经销商问题、NPC

简单选择排序：

def select_sort(items, comp=lambda x, y: x < y):
    items = items[:]
    for i in range(len(items)-1):
        min_index = i
        for j in range(i + 1, len(items)):
            if comp(items[j], items[min_index]):
                min_index = j
        items[i], items[min_index] = items[min_index], items[i]
    return items

冒泡排序

def bubble_sort(items, comp=lambda x, y: x > y):
    items = items[:]
    for i in range(len(items)-1):
        swapped = False
        for j in range(len(items)-1-i):
            if comp(items[j], items[j+1]):
                items[j], items[j+1] = items[j+1], items[j]
                swapped = True

        if not swapped:
            break
    return items


def Bubble_sort(items, comp=lambda x, y: x > y):
    items = items[:]
    for i in range(len(items)-1):
        swapped = False
        for j in range(len(items)-1-i):
            if comp(items[j], items[j+1]):
                items[j], items[j+1] = items[j+1], items[j]
                swapped = True
        if swapped:
            for j in range(len(items)-2-i, i, -1):
                if comp(items[j-1], items[j]):
                    items[j-1], items[j] = items[j], items[j-1]
                    swapped = True
        if not swapped:
            break
    return items

归并排序;

def merge(items1, items2, comp=lambda x, y: x < y):
    items = []
    index1, index2 = 0, 0
    while index1 < len(items1) and index2 < len(items2):
        if comp(items1[index1], items2[index2]):
            items.append(items1[index1])
            index1 += 1
        else:
            items.append(items2[index2])
            index2 += 1
    items += items1[index1:]
    items += items2[index2:]
    return items
def merge_sort(items, comp=lambda x, y: x < y):
    return _merge_sort(list(items), comp)


def _merge_sort(items, comp):
    if len(items) < 2:
        return items
    mid = len(items)//2
    left = _merge_sort(items[:mid], comp)
    right = _merge_sort(items[mid:], comp)
    return merge(left, right, comp)

顺序查找:

def seq_search(items, key):
    for index, item in enumerate(items):
        if item == key:
            return index
    return -1

 二分查找：

def bin_search(items, key):
    start, end = 0, len(items)-1
    while start <= end:
        mid = (start + end)//2
        if key > items[mid]:
            start = mid + 1
        elif key < items[mid]:
            end = mid - 1
        else:
            return mid
    return -1

快速排序

def quick_sort(items, comp=lambda x, y: x <= y):
    items = list(items)[:]
    _quick_sort(items, 0, len(items)-1, comp)
    return items


def _quick_sort(items, start, end, comp):
    if start < end:
        pos = _partition(items, start, end, comp)
        _quick_sort(items, start, pos-1, comp)
        _quick_sort(items, pos+1, end, comp)


def _partition(items, start, end, comp):
    pivot = items[end]
    i = start - 1
    for j in range(start, end):
        if comp(items[j], pivot):
            i += 1
            items[i], items[j] = items[j], items[i]
    items[i+1], items[end] = items[end], items[i+1]
    return i + 1