sort algorithm

#!/usr/bin/env python
# -*- coding:utf8 -*-

def bubble_sort(li):
    n = len(li)

    # j 代表 当前无序序列的个数
    for j in range(n, 1, -1):
        # 1 将序列最大数移动到无序序列尾端（遍历比较，前大后小则交换）
        swap_count = 0
        for i in range(0,j-1):
            if li[i] > li[i+1]:
                li[i], li[i+1] = li[i+1], li[i]
                swap_count += 1
        # 若没有发生交换，则算法退出
        if 0 == swap_count:
            return

    # 2 对剩余无序序列li[0:n-1]重复步骤1

def select_sort(li):
    n = len(li)

    # j 代表当前有序序列的个数(无序序列的首个元素位置)
    for j in range(0,n-1):
        # 1 找到最小元素并记录该值索引（遍历比较，小则更新）
        min_index = j
        for i in range(j + 1, n):
            if li[i] < li[min_index]:
                min_index = i

        # 至此，第min_index个元素就是最小元素
        # 2 交换最小值和无序序列首个元素
        li[min_index], li[j] = li[j], li[min_index]

    # 3 对剩余无序序列li[1:n]重复步骤1 2

def insert_sort(li):
    n = len(li)

    #j 代表当前有序序列的个数
    for j in range(1, n):
        # 1 将无序序列首个元素向前插入有序序列（反向遍历，前大后小则交换）
        for i in range(j, 0, -1):
            if li[i-1] > li[i]:
                li[i-1], li[i] = li[i], li[i-1]
            else:
                # 若没有发生前大后小则步骤1结束
                break

    # 2 对剩余无序序列重复步骤1

def shell_sort(li):
    n = len(li)
    # 1 确定步长分组（步长=长度的一半）
    gap = n // 2

    while gap > 0:
        # 2 组内插入排序
        for j in range(gap, n):
            for i in range(j, 0, -gap):
                if li[i-gap] > li[i]:
                    li[i-gap], li[i] = li[i], li[i-gap]
                else:
                    break
        # 3 缩小步长一半，重复步骤2
        gap = gap // 2

def quick_sort(li, start, end):
    if start >= end:
        return

    # 1 确定基准值已经基准索引（中间位置）
    pivot_index = (start + end) // 2
    head  = start
    tail = end

    while head < tail:
        # 2 在基准值前找比基准值大的元素（向后遍历），交换并更新基准索引
        while head < pivot_index and li[head] <= li[pivot_index]:
            head += 1
        li[head], li[pivot_index] = li[pivot_index], li[head]
        pivot_index = head
        # 3 在基准值后找比基准值小的元素（向前遍历），交换并更新基准索引
        while tail > pivot_index and li[tail] >= li[pivot_index]:
            tail -= 1
        li[tail], li[pivot_index] = li[pivot_index], li[tail]
        pivot_index = tail
        # 4 重复步骤2 3 直到首尾重合

    # 至此，原序列被分成li[start:pivot_index]和li[pivot_index+1:end+1]
    # 5 对前后序列重复步骤1 2 3 4
    quick_sort(li, start, pivot_index-1)
    quick_sort(li, pivot_index+1, end)
def merge_sort(li):
    n = len(li)
    if n <= 1:
        return
    # 1 递归分解，分到不能分为止
    left = li[:n//2]
    right = li[n//2:]
    merge_sort(left)
    merge_sort(right)

    # 2 返回合并，合并两个有序序列（同时遍历，选择小的放到新序列li）
    # left 和right已经有序--->因为我调用了merge_sort这个排序函数对left和right进行了排序
    li[:] = []

    l_index = 0
    r_index = 0

    while l_index < len(left) and r_index < len(right):
        if left[l_index] <= right[r_index]:
            li.append(left[l_index])
            l_index += 1
        else:
            li.append(right[r_index])
            r_index += 1

    # 至此，某个序列遍历完了，将另一个序列的后续元素追加到li后
    li += left[l_index:]
    li += right[r_index:]

def binary_search1(li, item):
    # 1 判断中间值是否是待查元素
    n = len(li)
    if n <= 0:
        return False

    mid = n // 2
    if li[mid] == item:
        return True
    # 2 对前子序列或后子序列递归执行
    elif item < li[mid]:
        return binary_search1(li[:mid], item)
    else:
        return binary_search1(li[mid+1:], item)

def binary_search2(li, item):
    start = 0
    end = len(li) - 1

    while start <= end:
        # 1 判断中间值是否是待查元素
        mid = (start + end) // 2
        if li[mid] == item:
            return True
        # 2 向前或向后缩小一半范围,重复步骤1
        if item < li[mid]:
            end = mid - 1
        else:
            start = mid + 1

    # 至此范围缩小到不存在还没查到
    return False