递归及应用（汉诺塔问题）、列表查找、列表排序

1、 递归

• 递归的两个特点：调用自身和结束条件
  fun3和fun4的打印顺序不同
  

2、汉诺塔问题

递归的应用
n=2时的移动步骤：

n个盘子时：将三个盘子从a移动到c

def hanoi(n, a, b, c):
    """
    :param n: 表示n个盘子
    :param a: 表示从那个柱子移动
    :param b: 表示经过那个柱子
    :param c: 表示到那个柱子
    :return:
    """
    if n > 0:
        hanoi(n - 1, a, c, b)
        print('moving from %s to %s' % (a, c))
        hanoi(n - 1, b, a, c)


hanoi(3, 'A', 'B', 'C')

测试结果：

3、查找

• 查找：在一些数据元素中，通过一定的方法找出与给定关键字相同的数据元素的过程
• 列表查找（线性表查找）：从列表中查找指定元素；输入列表和待查找元素；输出元素下标（未找到元素时一般返回None或-1）
• 内置列表查找函数index()，index()的本质是线性查找

3.1 顺序查找（linear Search）

• 顺序查找：也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止。
• 时间复杂度：O(n)

def linearsearch(li, val):
    for ind, v in enumerate(li):
        if v == val:
            return ind
    else:
        return None


print(linearsearch([1, 6, 3, 8, 2, 0], 2))

测试结果：

3.2 二分查找

• 二分查找：又叫折半查找，从有序列表的初始候选区li[0:n]开始，通过对查找的值与候选区中间值的比较，可以使候选区减少一半。
• 时间复杂度：O(logn)

def binary_search(li, val):
    """
    :param li:查找的列表，列表必须是由小到大的顺序排列
    :param val:查找的值
    :return:
    """
    left = 0
    right = len(li)
    while left <= right:
        mid = (left + right) // 2  # //表示整除，返回不大于结果的一个最大整数
        if li[mid] == val:
            return mid
        elif li[mid] > val:  # 表示查找的值在mid的左边
            right = mid - 1
        else:  # 表示查找的值在mid的右边
            left = mid + 1
    else:
        return None


print(binary_search([1, 2, 5, 7, 8, 10], 5))

测试结果：

测试二分查找用的时间：

import time


def cal_time(func):
    # 装饰器，用于测量方法的运行时间
    def wrapper(*args, **kwargs):
        t1 = time.time()
        result = func(*args, **kwargs)
        t2 = time.time()
        print("%s running time:%s secs." % (func.__name__, t2 - t1))
        return  result
    return wrapper

@ cal_time
def binary_search(li, val):
    """
    :param li:查找的列表，列表必须是由小到大的顺序排列
    :param val:查找的值
    :return:
    """
    left = 0
    right = len(li)
    while left <= right:
        mid = (left + right) // 2  # //表示整除，返回不大于结果的一个最大整数
        if li[mid] == val:
            return mid
        elif li[mid] > val:  # 表示查找的值在mid的左边
            right = mid - 1
        else:  # 表示查找的值在mid的右边
            left = mid + 1
    else:
        return None

li=list(range(10000))
binary_search(li, 3890)

4、列表排序

• 排序：将一组“无序”的记录序列调整为“有序”的记录序列。
• 列表排序：将无序列表变为有序列表；输入列表；输出有序列表。
• 升序与降序
• 内置排序函数sort()
• 排序方法
  

4.1 冒泡排序

• 列表每两个相邻的数，如果前面比后面大，则交换这两个数
• 一趟排序完成后，则无序区减少一个数，有序区增加一个数
• 时间复杂度：O(n²)

import random


def bubble_sort(li):
    for i in range(len(li) - 1):
        for j in range(len(li) - i - 1):
            if li[j] > li[j + 1]: # 从小到大排列
                li[j], li[j + 1] = li[j + 1], li[j]


li = [random.randint(0, 10000) for i in range(50)]
print(li)
bubble_sort(li)
print(li)

优化：

import random


def bubble_sort(li):
    for i in range(len(li) - 1):
        exchange = False
        for j in range(len(li) - i - 1):
            if li[j] > li[j + 1]:
                li[j], li[j + 1] = li[j + 1], li[j]
                exchange = True
        if not exchange: # 如果列表没有发生交换，说明已经排序完成
            return


li = [random.randint(0, 10000) for i in range(10)]
print(li)
bubble_sort(li)
print(li)

4.2 选择排序

• 一趟排序记录最小的数，放到第一个位置
• 再一趟排序记录列表无序区最小的数，放到第二个位置
• …进行循环
• 算法关键点：有序区和无序区、无序区最小数的位置
• 时间复杂度：O(n²)

def select_sort(li):
    # 在原始列表li上进行排序
    for i in range(len(li) - 1):  # i是第几趟
        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]


li = [3, 9, 5, 1, 0, 2, 4, 6]
select_sort(li)
print(li)

测试结果：

4.3 插入排序

• 时间复杂度：O(n²)

def insert_sort(li):
    for i in range(1, len(li)):  # i表示无序区的第一个值的下标
        tem = li[i]
        j = i - 1  # 表示有序区最后一个值的下标
        while j >= 0 and li[j] > tem: # 找插入的位置
            li[j + 1] = li[j]
            j -= 1
        li[j + 1] = tem


li = [1, 7, 4, 2, 9, 5, 0]
insert_sort(li)
print(li)

测试结果：