基础算法

 一:概述:

  算法(Algorithnm):------------------------------------一个计算过程,解决问题的方法。

  

  时间复杂度:----------------------------------------------用来估算运行效率的一个东西。

    时间复杂度是用来估算算法运行时间的一个式子(单位)。

    一般来说,时间复杂度高的算法比时间复杂度低的算法

    常见的时间复杂度(按效率排序)

    

    不常见的时间复杂度

    

    如何一眼判断时间复杂度度

    

    类比生活中的一些事件,估计时间:

      眨一下眼睛    -----------------------------  一瞬间/几毫秒

      口算 29+68    -----------------------------  几秒

      烧一壶水        -----------------------------  几分钟

      睡一觉           -----------------------------  几小时

      完成一个项目------------------------------  几天/几星期/几个月

      ...............................等。

1:

  

2:

  

3:

  

while n > 1:
   print(n)
 n = n // 2
n=64输出:

64
32
16
8
4
2
26=64
log264=6


O(log2n)
或
O(logn)

   空间复杂度----------------------------------------用来估算内存占用大小的一个式子

    可以用空间换时间

   递归-------------------------------------------------系统在实现子程序的调用时,要用栈方式管理调用子程序时的返回地址,子程序调用的内部实现为两个方面:

    1、通常,在一个算法中调用另一个算法时,系统需在运行被调用算法之前完成三件事:

      (1)将所有实参指针、返回地址等信息传递给被调用算法;

      (2)为被调用算法的局部变量分配存储区;

      (3)将控制转移到被调用算法的入口。

    2、在被调用算法返回调用算法时,系统也相应地要完成三件事:

      (1)保存被调用算法的计算结果;

      (2)释放分配给被调用函算法的数据区;

      (3)依照被调用算法保存的返回地址将控制转移到调用算法。

   递归的两个特点:

      1:调用自身

      2:约束

      看下面几个函数那个是函数?

        第一个符合递归的特点,掉用自身,也有约束。

  

    递归练习:

      实例一:

    

    

def fun(n):
    if n ==0:
        print("我的小鲤鱼",end='')
    else:
        print("抱着",end='')
        fun(n-1)
        print("的我",end='')
fun(5)


打印结果:
        抱着抱着抱着抱着抱着我的小鲤鱼的我的我的我的我的我
抱着抱着抱着抱着抱着我的小鲤鱼的我的我的我的我的我

    实例二:

      汉渃塔问题:

    

     n = 2时:

      1:把小盘从A移动到B

      2:把大盘从A移动到C

      3:把小盘从B移动到C

     n个盘子时:

      1:把n-1个圆盘从A经过C移动到B

      2:把n个盘子从A移动到C

      3:把n-1个盘子从B进过A移动到C

# -*- coding: utf-8 -*-
t = 0
def hanoi(n, A, B, C):
    global t
    if n > 0:
        hanoi(n-1, A, C, B)
        t += 1
        print("%s -> %s" % (A, C))
        hanoi(n-1, B, A, C)

hanoi(8,'A','B','C')
print(t)
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
C -> B
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
B -> A
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
C -> B
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
B -> A
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
C -> B
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
C -> B
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
B -> A
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
B -> A
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
C -> B
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
B -> A
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
C -> B
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
B -> A
C -> A
C -> B
A -> B
C -> A
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
A -> C
B -> C
B -> A
C -> A
B -> C
A -> B
A -> C
B -> C
255
执行结果

  汉渃塔移动次数的递推式h(x) = 2h(x-1)+1

    h(64)=18446744073709551615

    假设 婆罗门每秒钟搬一个盘子,则总共需要5800亿年。

 

原文地址:https://www.cnblogs.com/w-s-l123/p/8395246.html