zoukankan      html  css  js  c++  java
  • 基础算法

     一:概述:

      算法(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亿年。

     

  • 相关阅读:
    BUAA OO Unit3 Summary——万物即可形式化
    BUAA OO Unit2 Summary
    BUAA OO Unit1 Summary
    [机器学习笔记(三)]保存加载模型的几种方式
    交互式多媒体图书平台的设计
    【tips】带公式的Markdown转pdf
    【学习笔记】码农的自我修养之必备技能
    【Callback接口初探】工程化编程实战Callback接口学习笔记
    在linux下配置VSCode的开发环境
    网络知识水平与网络编程技能水平测试
  • 原文地址:https://www.cnblogs.com/w-s-l123/p/8395246.html
Copyright © 2011-2022 走看看