数据结构，算法持续更新ing

归并排序
排序过程如下（二路归并）：
①第一趟，将待排序列中的第一个元素与第二个元素归结为一组，将第三个元素与第四个元素归结为一组……将第 n－1 个元素与第 n 个元素归结为一组，然后将每一组里面的元素有序排列。
②第二趟，将待排序列中的第一、二、三、四个元素归结为一组，第五、六、七、八个元素归结为一组……同样，将每一组里面的元素有序排序。
…… …… 直至所有的元素有序排列。
③归并排序的时间复杂度为 O（logn），空间复杂度为 O（n）。但是它是稳定的排序算法，因为两两的归并，它们之间是基于相邻元素之间的比较。

def mergeSort(arr):
    import math
    if(len(arr)<2):
        return arr
    middle = math.floor(len(arr)/2)
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))

def merge(left,right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0));
    while left:
        result.append(left.pop(0))
    while right:
        result.append(right.pop(0));
    return result

快速排序
每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N2)，它的平均时间复杂度为O(NlogN)。

lst = [1, 6, 9, 5, 455, 0, 55559, 97]


def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp:
            right -= 1
        li[left] = li[right]
        while left < right and li[left] < tmp:
            left += 1
        li[right] = li[left]
    li[left] = tmp
    return left

堆排序
是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序
基本思路：

a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;

b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;

c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
　　
　
快速排序

lst = [1, 2, 55, 16, 31, 45, 999, 0]


def select_sort(li):
    for i in range(len(li)-1):
        index = i
        for j in range(i + 1, len(li)):
            if li[index] > li[j]:
                index = j
        if index != i:
            li[index], li[i] = li[i], li[index]
    return li


print(select_sort(lst))

二分查找
是不断地将有序数据集进行对半分割，并检查每个分区的中间元素。

def binner_search(lst, val):
    left = 0
    right = len(lst)

    while left <= right:
        mid = (left + right) // 2
        if lst[mid] > val:
            right = mid - 1
        elif lst[mid]<val:
            left = mid+1
        else:
            return mid
    else:
        return None

插入排序
其实就是我们每次从后部分拿出一个数放到前部分去遍历比较。

lst = [1, 5, 6, 44, 88, 45632, 20, 0]


def insert_sort(li):
    for i in range(len(li) - 1):
        while li[i + 1] < li[i] and i >= 0:
            li[i + 1], li[i] = li[i], li[i + 1]
            i -= 1
    return li


print(insert_sort(lst))

冒泡排序
相邻两数比较，小的升上去

def bubble_sort(lst):
    for i in range(len(lst) - 1):
        print('i>>>',i)
        exchange = False
        for j in range(len(lst) - i - 1):
            print('j>>>>>>',j)
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
                exchange = True
        if not exchange:
            return lst


a = [ 5, 9, 77, 1111, 5555, 944644646, 54, 33, 41, 23]
print(bubble_sort(a))