算法

本章节主要介绍了二分查找法、三种低级排序的方法（冒泡排序、选择排序、插入排序）、三种高级排序方法（快速排序、堆排序、归并排序）。

二分查找法

二分查找法是基于此列表是有序的，比如是一个升序。

def binary_search(li, val):
    """
    二分查找法，成功找到值则返回索引，否则返回-1
    :param li:
    :param val:
    :return:
    """
    low = 0
    height = len(li) - 1
    while low <= height:
        mid = (low + height) // 2
        if li[mid] > val:
            height = mid - 1
        elif li[mid] < val:
            low = mid + 1
        else:
            return mid
    else:
        return -1

冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

def bubble_sort(li):
    """
    冒泡排序
    :param li:
    :return:
    """
    for i in range(len(li) - 1):
        # i表示的是第几趟
        for j in range(0, len(li) - i - 1):
            if li[j] > li[j + 1]:
                li[j], li[j + 1] = li[j + 1], li[j]


def bubble_sort2(li):
    """
    冒泡排序改进版，就是一趟没有任何改变，则直接结束
    :param li:
    :return:
    """
    for i in range(len(li) - 1):
        # i表示的是第几趟
        change = False
        for j in range(0, len(li) - i - 1):
            if li[j] > li[j + 1]:
                li[j], li[j + 1] = li[j + 1], li[j]
                change = True
        if not change:
            return

选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

def select_sort(li):
    for i in range(len(li) - 1):
        min_loc = i  # 最小数位置
        for j in range(i + 1, len(li) - 1):
            if li[j] < li[min_loc]:
                min_loc = j
        li[i], li[min_loc] = li[min_loc], li[i]

插入排序

插入排序的思想：把列表分成有序区和无序区，拿无序区的第一个数，然后把此数放到有序区合适的位置。如此循环，直到无序区没有数。

def insert_sort(li):
    for i in range(1, len(li)):
        # 无序区的第一个数
        tmp = li[i]
        # 有序区的最后一个位置
        j = i - 1
        while li[j] > tmp and j >= 0:
            li[j + 1] = li[j]
            j -= 1
        li[j+1] = tmp

快速排序

快速排序的思想：从列表中取一个元素（一般是第1个），然后遍历列表，使得此元素的左边均比它小，右边的元素均比它大，然后继续通过递归实现排序

def partition(li, left, right):
    """
    此函数用于对于列表li，首先从一个随机位置和第一个位置交换数值，然后把第一个数放到一个位置，此位置的左边
    数值均比它小，右边的数值均比它大，返回此位置的索引
    :param li: 列表
    :param left: 最左边的位置
    :param right: 最右边的位置
    :return: 返回此位置的索引
    """
    # 交换数
    random_index = random.randint(left + 1, right)
    li[left], li[random_index] = li[random_index], li[left]
    tmp = li[left]
    while left < right:
        # 当left=right时，即找到位置时，退出循环
        while left < right and li[right] >= tmp:
            # 当找到比tmp小的数时退出循环
            right -= 1
        li[left] = li[right]
        while left < right and li[left] <= tmp:
            # 当找到比tmp大的数时退出循环
            left += 1
        li[right] = li[left]
    li[left] = tmp
    return left


def _quick_sort(li, left, right):
    if left < right:
        # 表明有起码有两个元素
        mid = partition(li, left, right)
        _quick_sort(li, left, mid - 1)
        _quick_sort(li, mid + 1, right)

堆排序

概念解析：
二叉树：度不超过2的树（节点最多有两个叉）
满二叉树：如果每层的节点数都达到最大值的二叉树
完全二叉树：叶节点只能出现在最下层或是次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树

小根堆：满足父亲节点均比孩子节点小的完全二叉树
大根堆：满足父亲节点均比孩子节点大的完全二叉树
向下调整：顶端节点不符合堆的字义，而其左右的子树符合堆的定义，可通过向下调整帮顶端找到合适的位置。

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。
a.假设给定无序序列结构如下

2.此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

4.找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

此时，我们就将一个无需序列构造成了一个大顶堆。
步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。
a.将堆顶元素9和末尾元素4进行交换

b.重新调整结构，使其继续满足堆定义

c.再将堆顶元素8与末尾元素5进行交换，得到第二大元素8.

后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

def sift(li, low, high):
    """
    向下调整
    有一个堆，最顶端（省长）不是堆，其左右堆均是堆，现在要调整省长的位置
    :param li: 列表
    :param low: 堆的开始位置
    :param high: 堆的结束位置
    :return:
    """
    tmp = li[low]  # 堆顶端的值
    i = low  # 父亲的位置
    j = 2 * i + 1  # 左孩子的位置
    while j <= high:
        # 如果右孩子存在并且右孩子较大
        if j + 1 <= high and li[j + 1] > li[j]:
            # 把孩子当中较大的给j保存
            j += 1
        # 较大的孩子如果比省长大，则原省长位置就给此孩子
        if tmp < li[j]:
            li[i] = li[j]
            i = j
            j = 2 * i + 1
        else:
            break
    li[i] = tmp



def heap_sort(li):
    """
    对列表li利用堆进行排序，首先建堆，然后挨个数
    :param li:
    :return:
    """
    n = len(li)
    # 第一步、建堆
    for i in range(n // 2 - 1, -1, -1):
        sift(li, i, n - 1)
    # 第二步，挨个出数
    # j表示最后一个元素的位置
    for j in range(n - 1, -1, -1):
        # 交换省长和傀儡的位置，同时元素减1
        li[0], li[j] = li[j], li[0]
        sift(li, 0, j - 1)

利用堆模块排序

import heapq


def heap_sort(li):
    """
    利用heapq模块实现排序功能
    :param li:
    :return:
    """
    # 构造堆
    heapq.heapify(li)
    n = len(li)
    new_li = []
    for i in range(n):
        # heapop每次会从列表获取最小的值
        new_li.append(heapq.heappop(li))
    return new_li

heapq.nlargest(k, li)  # 从列表中获取最大的k个值
heapq.nsmallest(k, li)  # 从列表中获取最小的k个值

归并排序

归并排序是用分治思想，分治模式在每一层递归上有三个步骤：
分解（Divide）：将n个元素分成个含n/2个元素的子序列。
解决（Conquer）：用合并排序法对两个子序列递归的排序。
合并（Combine）：合并两个已排序的子序列已得到排序结果。

def merge(li, low, mid, high):
    """
    一次归并
    :param li:
    :param low:
    :param mid:
    :param high:
    :return:
    """
    i = low
    j = mid + 1
    l_tmp = []
    # 左右两边的指针都还未遍历完时
    while i <= mid and j <= high:
        if li[i] < li[j]:
            l_tmp.append(li[i])
            i += 1
        else:
            l_tmp.append(li[j])
            j += 1
    while i <= mid:
        l_tmp.append(li[i])
        i += 1
    while j <= high:
        l_tmp.append(li[j])
        j += 1
    li[low:high+1] = l_tmp


def _merge_sort(li, low, high):
    if low < high:
        mid = (low + high) // 2
        _merge_sort(li, low, mid)
        _merge_sort(li, mid+1, high)
        merge(li, low, mid, high)