python3实现经典算法

一、折半查找
必要条件，要查找的数列必须为小到大有序排列。每次查找先折半，在区域内继续折半查找，时间复杂度为logn

# 递归实现
def binary_search(num, l, start, end):  # 二分法查找，成功返回索引值，否则返回-1
    if start <= end:
        mid = (start + end) // 2        # 算出中间值
        if l[mid] == num:
            return mid
        elif l[mid] < num:
            start = mid + 1
            return binary_search(num, l, start, end)
        else:
            end = mid - 1
            return binary_search(num, l, start, end)
    else:
        return -1

二、冒泡排序
冒泡排序算法，大的元素向后面移，一直移到最后乱序的最后一个位置，时间复杂度为n^2

def bubble_sort(l):
    for i in range(len(l)):     # 排序一趟
        is_sort = False     # 判断是否排好序的标识
        j = 0
        while j < len(l) - 1 - i:     # 每次从第一个开始，到排好序的前一个结束
            if l[j] > l[j+1]:     # 把最大的往后移
                l[j], l[j+1] = l[j+1], l[j]
                is_sort = True       # 没有交换说明是有顺序的，停止排序
            j += 1
        if not is_sort:
            break
    return l

三、选择排序
选择排序，从第一个元素开始，和后面每个元素比较，最小的和前面索引互换，从排好序的后面一直循环，至到全部换完，排序完成。时间复杂度为n^2

def select_sort(l):
    for i in range(len(l)):
        min_index = i       # 记录最小索引的变量
        j = i               # 从排好序的后一个元素开始
        while j < len(l):
            if l[min_index] > l[j]:     # 找最小的数
                min_index = j       # 把最小元素的索引保存
            j += 1
        # l[min_index], l[i] = l[i], l[min_index]   # python特有的换值语法
        temp = l[i]
        l[i] = l[min_index]
        l[min_index] = temp
    return l

四、插入排序
插入排序，第一个元素可以理解为排好序的，从第二个元素开始和前面的排好序的元素比较，插入比它小的元素后面，一直循环，至到排序完成。时间复杂度为n^2

def insertion_sort(l):
    current = 0     # 定义中间变量
    for i in range(len(l)):
        pre_index = i - 1
        current = l[i]  # 存储当前插入元素
        while pre_index >= 0 and current < l[pre_index]:    # 向前比较元素，一直比较到合适位置
            l[pre_index+1] = l[pre_index]   # 比较元素后移一位
            pre_index -= 1
        l[pre_index+1] = current    # 插入元素到合适位置
    return l

五、归并排序
1）把长度为 n 的输入序列分成两个长度为 n / 2 的子序列
2）对这两个子序列分别采用归并排序
3）将两个排序好的子序列合并成一个最终的排序序列
空间换时间，空间复杂度为n，时间复杂度为nlogn

def merge_sort(l):
    if len(l) < 2:
        return l    # 递归退出条件
    else:
        mid = len(l) // 2   # 切割成两部分
        left = merge_sort(l[:mid])      # 左边部分
        right = merge_sort(l[mid:])     # 右边部分
        i, j = 0, 0
        temp = []   # 接收新的list
        while i < len(left) or j < len(right):  # 两边循环
            if(i < len(left)) and (j < len(right)): # 正常情况，小的放前面
                if left[i] < right[j]:
                    temp.append(left[i])
                    i += 1
                else:
                    temp.append(right[j])
                    j += 1
            elif i >= len(left):    # 右边长一个，加在后面
                temp.append(right[j])
                j += 1
            else:
                temp.append(left[i])
                i += 1
        return temp