算法篇01---汉诺塔问题、查找、排序问题

一、递归---汉诺塔问题

        

 递归描述：

def hanoi(n,a,b,c):  # 参数意义：n个盘子，从a经过b移动到c
    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')   # 输出7

二、查找

查找：在一些数据元素中，通过一定方法找出与给定关键字相同的数据元素的过程

列表查找（线性表查找）：从列表中查找指定元素

>>> 输入：列表、待查找元素

>>>输出：元素下标（未找到元素时一般返回None或-1）

内置列表查找函数：index( ),这是顺序查找，因为二分查找必须是有序列表

(1) 顺序查找（线性查找）

从列表第一个元素开始，顺序进行搜索，知道找到元素或搜索到列表最后一个元素为止。

时间复杂度：O(n)

def linear_search(list,val):    # 输入一个列表和一个待查找元素val
    for index,v in enumerate(list):
        
        if v==val:      # 找到元素val
            return index   # 返回下标
        else:           # 没有找到，返回None或-1
            return None 
#等同于
def linear_search(data_set,value):
    for i in range(range(data_set)):
        if data_set[i] == value:
            return i
    return
    

（2）二分法查找

        又叫折半查找，从有序列表的初始候选去 list[0:n] 开始，通过对 待查找的值 与 候选区中间值的比较，可以使候选区减少一半。

 时间复杂度：循环减半情况：O(log n)

def binary_search(list,value):
    left=0
    right=len(list)-1
    while left <= right:    # 候选区有值
        mid=(left+right)//2   # 整除2：向下取整
        if list[mid]==val:    
            return mid
        elif list[mid] > val: 
            right=mid-1
        else:  # list[mid]<val 待查找的值在中间值mid右侧
            left=mid+1
    else:
        return None

如果列表时有序，直接用二分查找；如果无序且只查找一次，就没必要排序，直接顺序查找即可；如果以后要查找很多次，就排个序。

三、排序

排序：将一组“无序”的记录序列调整为“有序”的记录序列

列表排序：将无序列表变为有序列表(升序和降序)

• 输入：列表
• 输出：有序列表

内置排序函数：sort( )

常见的排序算法:

(1) 冒泡排序Bubble Sort（以升序为例）

• 列表每两个相邻的数，如果前面比后面的大，则交换这两个数。
• 一趟排序完成之后，则无序去减少一个数，有序区增加一个数。

————————>>>

• 整个排序过程进行 len(list)-1 趟（ n=len(list) ）。   
• 代码关键：无序区范围。 第0、1、2、...、n-2 趟，一共n-1趟。
• 第 i 趟时，无序区为【0，n-i-1】，n=len(list)，箭头最后指向 n-i-2 。
• 时间复杂度：O(n^2)
• 如果在某趟排序过程中没有发生数字交换，我们就可以认为 列表已经排好序的，就不需要再进行后续那么多躺了。

import random
# 升序
def bubble_sort(li):
    n=len(li)
    for i in range(len(li)-1):  # 一共进行 n-1 趟,这是第 i 趟
        # 改进：在每一趟处加一个标志位
        exchange = False
        for j in range(n-i-1):  # 箭头在j处，不能指到索引 n-i-1处
            if li[j] > li[j+1]:  # 降序：改成 < 即可
                li[j],li[j+1] = li[j+1],li[j]    #交换两个数字
                exchange = True  # 如果交换了，就变成True，没有交换就仍然是False

        if not exchange：   # 如果一趟之后，exchange仍然是False，说明这一趟没有执行if交换
            return


li=[random.randint(0,1000) for i in range(100)]  # 列表推导式
print(li)
bubble_sort(li)
print(li)

(2) 选择排序

• 第一趟排序记录最小的数，放到第一个位置
• 再一趟记录 无序区最小的数，放在第二个位置。以此类推

算法关键点：有序区和无序区，无序区最小数的位置。

时间复杂度：O(n^2)

def select_sort(li):
    for i in range(len(li)-1):   # 第几趟
        min_ind=i
        for j in range(i+1,len(li)):   # 无序区
            if li[j] < li[min_ind]:
                min_ind=j
        li[i],li[min_ind] = li[min_ind],li[i]    # 最小值和无序区第一个数互换
        print(li)   # 可以看到每趟排序后的结果

li=[3,2,4,5,7,1,8]
select_sort(li)

(3) 插入排序

 

 一开始摸牌，从7（下标1）开始摸。

时间复杂度：O(n^2)

def insert_sort(li):
    for i in range(1,len(li)):   # i 表示摸到手里的牌的下标（无序区）
        tmp=li[i]
        j=i-1   # 在手里的牌（最右边）的下标
        while j>=0 and li[j]>tmp :  # 摸到的牌tmp 小于 j 位置的牌，将 j 位置的牌向右移一格
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tmp # 空着的位置：最左边或者j位置的数 小于 tmp

        # print(li) # 每完成一趟排序，输出一次

li=[2,3,5,7,4,6,8,1,9]
print(li)
insert_sort(li)

如果想检测某个方法运行时间：

• from cal_time import *
• @cal_time 
  • 要检测的代码块

(4) 快速排序

特点：快

思路：

• 取一个元素p（第一个元素），使元素p归为；
• 列表被p分成两部分，左边都比p小，右边都比p大；
• 递归完成排序。

快速排序框架

 现在主要就是写： partition函数-----让第一个元素归位，作为mid

def partition(li,left,right):
    tmp=li[left]
    while left < right: # 最起码有两个元素
        while left < right and li[right] >= tmp:  # 右边的值 大于 tmp时，继续找
            right -=1      # 右边像左移动一位
        li[left]=li[right]    # 右边的元素 小于tmp ，需要将其移动到左边空位：left

        while left < right and li[left] <= tmp:  # 刚移过来的值小于tmp，因此看下一个元素
            left +=1
        li[right]=li[left]    # 左边的元素 大于 tmp，需要将其移到右边空位
        
    # left与right重合的情况
    li[left]=tmp   # 只剩这个空位，right和left重合，将tmp归位
    return left    # 返回第一个归位的位置 索引，将其作为mid

def quick_sort(li,left,right):
    if left<quick:  # 至少存在两个元素
        mid=partition(li,left,right)
        quick_sort(li,left,mid-1)
        quick_sort(li,mid+1,right)

快速排序效率:，即快速排序的时间复杂度：O(nlog n)

快速排序的问题：

• 存在最坏情况：每次只少一个数，例如 【9，8，7，6，5，4，3，2，1】排序时，解决方法就是 随机找一个中间的数和第一个数交换。
• 用递归存在一些缺点：会消耗很多系统资源。