金沙国际官网_金沙国际平台登录

因为这个金沙国际官网_金沙国际平台登录网站与很多的大型澳门赌场都有合作,金沙国际官网_金沙国际平台登录尽职尽责,高效执行,保持好奇心,不断学习,追求卓越,点击进入金沙国际官网_金沙国际平台登录马上体验吧,所以现在也正式地开始了营业。

您的位置:金沙国际官网 > 编程 > 递归算法

递归算法

发布时间:2019-11-03 17:53编辑:编程浏览(164)

    int height(BitNode *t){

    上一篇简单讲解了 线程和线程池以及上下文切换。创建线程代价高昂,默认每个线程都要占用大量虚拟内存1M。更有效的做法使用线程池,重复利用线程。在.NET4.0中引入了TPL任务并行库,你可以在将精力集中于程序要完成的工作,同时最大程度地提高代码的性能。在C#5.0中引入了async 和 await关键字,基于任务的异步模式(TAP),所以了解Task对后面学习异步操作会简单些。 

      我们经常在python的模块目录中会看到 "__init__.py"  这个文件,那么它到底有什么作用呢?

    if(t==null)
        return 0;
    else
        return 1+Max{height(t->lchild),height(t->rchild)};
    

    任务是封装了以异步方式执行的工作。当启动一个任务,控制几乎立即返回调用者,无论任务要执行多少工作。

     

    }

    创建Task任务

    1. 标识该目录是一个python的模块包(module package)

      如果你是使用python的相关IDE来进行开发,那么如果目录中存在该文件,该目录就会被识别为 module package 。

    您可能感兴趣的

     有三种创建方式

    2. 简化模块导入操作

      假设我们的模块包的目录结构如下:

    .
    └── mypackage
        ├── subpackage_1
        │   ├── test11.py
        │   └── test12.py
        ├── subpackage_2
        │   ├── test21.py
        │   └── test22.py
        └── subpackage_3
            ├── test31.py
            └── test32.py
    

       

      如果我们使用最直接的导入方式,将整个文件拷贝到工程目录下,然后直接导入:

    from mypackage.subpackage_1 import test11
    from mypackage.subpackage_1 import test12
    from mypackage.subpackage_2 import test21
    from mypackage.subpackage_2 import test22
    from mypackage.subpackage_3 import test31
    from mypackage.subpackage_3 import test32
    

      当然这个例子里面文件比较少,如果模块比较大,目录比较深的话,可能自己都记不清该如何导入。(很有可能,哪怕只想导入一个模块都要在目录中找很久)

      这种情况下,__init__.py 就很有作用了。我们先来看看该文件是如何工作的。

    • 非递归先序遍历二叉树https://www.cnblogs.com/Coeus-P/p/9353186.html
    • 非递归后序遍历二叉树版本二
    • 递归算法--二叉树宽度
    • 递归算法--交换二叉树左右子树
    • 递归算法--二叉树高度
    • 递归算法--二叉树中叶子结点
    • 递归算法--二叉树中度为2的结点
    • 递归算法--二叉树中度为1的结点
    • 非递归实现斐波那契数列
    • 非递归后序遍历二叉树版本一
    • 层次遍历二叉树
    • 非递归中序遍历二叉树
    • 非递归先序遍历二叉树
    • 使用task构造函数
    • task工厂类静态方法
    • 使用.NET4.5新引入的Task.run()。

    2.1 __init__.py 是怎么工作的?

      实际上,如果目录中包含了 __init__.py 时,当用 import 导入该目录时,会执行 __init__.py 里面的代码。

      我们在mypackage目录下增加一个 __init__.py 文件来做一个实验:

    .
    └── mypackage
        ├── __init__.py
        ├── subpackage_1
        │   ├── test11.py
        │   └── test12.py
        ├── subpackage_2
        │   ├── test21.py
        │   └── test22.py
        └── subpackage_3
            ├── test31.py
            └── test32.py
    

      mypackage/__init__.py 里面加一个print,如果执行了该文件就会输出:

    print("You have imported mypackage")
    

      下面直接用交互模式进行 import

    >>> import mypackage
    You have imported mypackage
    

      很显然,__init__.py 在包被导入时会被执行。

    我们创建一个输出300万个32位字符的GUID任务分别使用三种不同方式实现。代码如下 constint RepeatCount = 1000000; //重复次数

    2.2  控制模块导入

      我们再做一个实验,在 mypackage/__init__.py 添加以下语句:

    from subpackage_1 import test11
    

      我们导入 mypackage 试试:

    >>> import mypackage
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "/home/taopeng/Workspace/Test/mypackage/__init__.py", line 2, in <module>
        from subpackage_1 import test11
    ImportError: No module named 'subpackage_1'
    

      报错了。。。怎么回事?

      原来,在我们执行import时,当前目录是不会变的(就算是执行子目录的文件),还是需要完整的包名。

    from mypackage.subpackage_1 import test11
    

      综上,我们可以在__init__.py 指定默认需要导入的模块  

                var listGuid = new BlockingCollection<string>();
    
                //Action无返回值 
                Action dowork = () =>
               {
                   for (var count = 0; count < RepeatCount; count++)
                   {
                       listGuid.Add(Guid.NewGuid().ToString("N"));
                   }
               };
                Task task1 = new Task(dowork);  //1)使用构造函数
                task1.Start();
                Task task2 = Task.Factory.StartNew(dowork); //2)Task工厂方法,直接运行,不需要在调用start()
                Task task3 = Task.Run(dowork); //3)4.5 Task.Run 是Task.Factory.StartNew简化方式;直接运行,不需要在调用start()
    
                Task.WaitAll(task1, task2, task3); //等待所有任务完成,相当于 thread.join()
                Console.Write($"生成数量:{listGuid.Count / 10000}万");
    

    2.3  偷懒的导入方法

      有时候我们在做导入时会偷懒,将包中的所有内容导入

    from mypackage import *
    

      这是怎么实现的呢? __all__ 变量就是干这个工作的。

      __all__ 关联了一个模块列表,当执行 from xx import * 时,就会导入列表中的模块。我们将 __init__.py 修改为 。

    __all__ = ['subpackage_1', 'subpackage_2']
    

      这里没有包含 subpackage_3,是为了证明 __all__ 起作用了,而不是导入了所有子目录。

    >>> from mypackage import *
    >>> dir()
    ['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'subpackage_1', 'subpackage_2']
    >>> 
    >>> dir(subpackage_1)
    ['__doc__', '__loader__', '__name__', '__package__', '__path__', '__spec__']
    

      子目录的中的模块没有导入!!!

      该例子中的导入等价于

    from mypackage import subpackage_1, subpackage_2
    

      因此,导入操作会继续查找 subpackage_1 和 subpackage_2 中的 __init__.py 并执行。(但是此时不会执行 import *

      我们在 subpackage_1 下添加 __init__.py 文件:

    __all__ = ['test11', 'test12']
    
    # 默认只导入test11
    from mypackage.subpackage_1 import test11
    

      再来导入试试

    >>> from mypackage import *
    >>> dir()
    ['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'subpackage_1', 'subpackage_2']
    >>> 
    >>> dir(subpackage_1)
    ['__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', 'test11']
    

      如果想要导入子包的所有模块,则需要更精确指定。

    >>> from mypackage.subpackage_1 import *
    >>> dir()
    ['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'test11', 'test12']
    

    输出图片 1

    3. 配置模块的初始化操作

      在了解了 __init__.py 的工作原理后,应该能理解该文件就是一个正常的python代码文件。

      因此可以将初始化代码放入该文件中。

      

     

     

      

     

      

    上述实例创建一个没有返回值的任务,当然也可以通过Task<TResult> 来创建返回值的异步操作。

    连续任务

    本文由金沙国际官网发布于编程,转载请注明出处:递归算法

    关键词: