递归算法

二叉树层次遍历 //思路 特殊情况 ，根节点为null，深度为0，return 0 借助队列，队列储存每一层的所有节点， 先保存数组长度，用于控制依次遍历循环――遍历每一个节点保存值，该节点的所有子结点从队尾入队，访问过的节点从头出队 注意――需要先把width存下来，用于for循环的结束标志，因为for循环里面直接操作了queue，不能去都不敢动态获取 队列初始值为root，对每一层都要进行上述遍历――while循环控制，队列空代表叶节点这一层遍历完成，此时遍历结束，退出循环 每次循环开始前初始化一个curNodes储存该层所有节点，每次循环结束，将curNodes压入result var levelOrder = function(root) { if (root === null) return []; //空树 var result = [], queue = [root]; while (queue.length) { let width = queue.length; //需要先把width存下来，用于for循环，for循环里面直接操作了数组 let curNodes = []; for (let i = 0; i < width; i++) { let node = queue.shift(); curNodes.push(node.val); node.left ?

简单的来说，递归就是一个概念能够用自身来解释，比如说一本字典，每个字词的解释是依靠字典中其他的字词来解释的。一般来说，计算机中遇到的递归问题大多是把一个问题分解成规模更小的子问题求解，再进行合并。 一个具有递归性质的问题，大多具有两个特征，第一个是状态转移方程也就是递归方程，比如在求解阶乘时，n！=n*(n-1)!，就将求解n的阶乘转换为求解n-1的阶乘。第二个特征就是终止条件，一个递归是一类问题的求解，必定有一个结果 无法一只递归下去，有一个结束条件，也就是当问题规模简化的足够小的时候可以直接的出答案。在求解阶乘时，当问题过为1的时候就直接输出1. int f ( n ) { if ( n == 1 ) //终止条件 { return 1 ; } else { return n * f ( n - 1 ); //递归方程 } } 递归执行时，递归函数会被反复地调用，一层一层的进入，到达终止条件后，再一层一层出来，为了保证结果的正确性，每一层函数的运算结果和状态都必须保存在系统所分配的栈里面，当数据量很大的时候，递归所占用的空间和运行时间会非常恐怖，效率也很低 这里再介绍一种和递归类似的但执行效率更高的动态规划算法。 递归算法是从顶置低求解问题，而・动态规划算法是从低置顶求解问题，同样也需要状态转移方程方程，和初始条件，相较于递归算法的优势，动态规划算法不需要反复调用自身函数

递归和动态编程(Dynamic Programming, DP)是算法类问题中的难点所在。算法的核心在于找到状态转移方程，即如何通过子问题解决原问题。 相似 递归和动态编程能解决的问题都有一个特性：原问题(problem)可以分解成若干个子问题(sub-problem)，只有先解决了子问题才能进一步解决原问题。子问题的解决方式形式上与原问题一致。 区别 DP和递归有什么不同？最大的区别在于，DP 存储子问题的结果 ，当子问题已经被计算过，直接返回结果。因此，当需要重复计算子问题时，DP的时间效率高很多，但 需要额外的空间 。 递归的时间成本随递归深度n(单条路径中递归调用的次数)成指数增长；空间复杂度为O(n)。 动态编程的核心在于，如果在一个问题的解决方案中，子问题被重复计算，那么就可以利用记录中间结果，达到用空间换取时间的目的。 什么是动态规划 来源：51CTO 作者： QilanAllen 链接：https://blog.csdn.net/QilanAllen/article/details/100805998

递归：代码简洁，但是效率低（每次函数调用都有时间和空间的开销）； 循环：和递归相反； 1 斐波那契数列 题目：写入一个函数，输入n，求斐波那契（Fibonacci）数列的第n项，斐波那契数列的定义：f(n) = f(n-1) + f(n-2)，初始值f(0)=0且f(1)=1； 解题思路： （1）递归：根据f(n)的定义来递归计算； （2）循环：定义三个长整数one、Two和Res，迭代计算； 未完待续～ 来源：博客园 作者： 博1990 链接：https://www.cnblogs.com/bo1990/p/11449220.html

递归的定义和优缺点 递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。 递归算法解决问题的特点： (1) 递归就是在过程或函数里调用自身。 (2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。 (3) 递归算法解题通常显得很简洁，但运行效率较低。所以一般不提倡用递归算法设计程序。 (4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

这个也是学校的课设，处理的是 0--9 的阶乘。 设计思路： 总体设计思路和32位无符号数类似，结果存放在内存中；最主要的特点就是递归调用程序，即程序调用自己程序，最后通过比较一个界值来实现跳转。本设计的是0-9内的阶乘算法，有一个设计技巧：已知8!=40320（9D80H），9!=362880（58980H），由于进行乘法的16位运算MUL时，默认使用AX寄存器的值，乘积的结果放在DX：AX中。通过观察9!的16进制值知，在DX：AX中能放下。使用BX作为乘数源，从1往上递增。即当输入数据为9时，BX从1直到9完成递归调用。因为到8!时，AX中为9D80H，能够存放下，此时BX为9，运算后恰好能将值送到DX：AX中。如果从9递减到1的话，当BX为3时，运算结果（9X8X7X6X5X4X3=181440）对应16进制为2C4C0H，此时单用AX进行运算就会造成失真，如果要运算，需要先算DX的，再算AX的，没有必要。 输入：输入为0-9的字符。 运算（FAC）：内部使用16进制进行运算。 调整（ADJUST）：由于输出为10进制的运算后的数据，所以需要进行调整。内部实现是除10取余数，然后再入栈；除到最后时出栈，送到内存中去（只是为了内存首地址存储的是最高位，且按顺序存储）。 输出（OUTPUT）：从内存中取出数据，调用21H的02H功能号，进行输出。 代码： //fac.asm

leetcode_2: #306（未解决）很沮丧，今天这个问题没能解决出来，部分网友说回溯法能做，这个高级的算法还没学，之后补充 题目：累加数 　　Additive number is a string whose digits can form additive sequence. '0'-'9' , write a function to determine if it's an additive number. 1, 2, 03 1, 02, 3 今天学的是 https://blog.csdn.net/weixin_37373020/article/details/80567919 def junge(a,b,s): 　　c=a+b 　　temp=str(a)+str(b)+str(c) 　　if s==temp: 　　　　return True 　　elif len(s)<len(temp): 　　　　return False 　　if s[:len(temp)]==temp: 　　　　return junge(b,c,s[len(str(a)):]) 　　else: 　　　　return False for i in range(1,len(num)//2+1): 　　a=int(num[:i]) 　　j=1 　　while j+i<(len(num)+i)//2+1:

题目： n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 上图为 8 皇后问题的一种解法。 给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。 每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。 示例: 输入: 4 输出: [ [".Q…", // 解法 1 “…Q”, “Q…”, “…Q.”], ["…Q.", // 解法 2 “Q…”, “…Q”, “.Q…”] ] 解释: 4 皇后问题存在两个不同的解法。 代码： class Solution { public: vector<vector<string>> solveNQueens(int n) { vector<vector<string>> ret; string str(n, '.'); vector<string> temp(n, str); solve(0, n, temp, ret); return ret; } private: void solve(int i, int& n, vector<string> temp, vector<vector<string>>& ret){ if(i == n) { ret.push_back(temp); } else { for(int j = 0; j <

2019独角兽企业重金招聘Python工程师标准>>> 非递归版的归并排序，省略了中间的栈空间，直接申请一段O(n)的地址空间即可，因此空间复杂度为O(n),时间复杂度为O(nlogn); 算法思想： 　　开始以间隔为1的进行归并，也就是说，第一个元素跟第二个进行归并。第三个与第四个进行归并； 　　然后，再以间隔为2的进行归并，1-4进行归并，5-8进行归并； 　　再以2*2的间隔，同理，知道2*k超过数组长度为止。 while (i< length){ Merge(arr,temp,i,length); i *= 2 ; } 　　当不够两组进行归并是，如果超过k个元素，仍然进行归并；如果剩余元素不超过k个元素，那么直接复制给中间数组。 while (i <= length- 2 * k){ sort(arr1,temp,i,i +k- 1 ,i+ 2 *k- 1 ); i += 2 * k; } 　 if (i < length-k+ 1 ) // 如过剩余个数比一个k长度还多...那么就在进行一次合并 sort(arr1,temp,i,i+k- 1 ,length- 1 ); else for (j=i;j<length;j++ ) temp[j] = arr1[j]; 主要代码： void MergeSort( int *arr, int length){ int *temp

CLR 混合线程同步构造 “基元线程同步构造”讨论了基元用户模式和 内核模式线程同步构造。其他所有线程同步构造都基于它们而构建，而且一般都合并了用户模式 和 内核模式构造，我们称为 混合线程同步构造 。 没有竞争时 —— 用户模式，有竞争时—— 内核模式。 下面是一个混合线程同步锁的例子： internal sealed class SimpleHybridLock: IDisposable{ // The Int32 is used by the primitive user•mode constructs (Interlocked methods) private Int32 m_waiters = 0; // The AutoResetEvent is the primitive kernel•mode construct private readonly AutoResetEvent m_waiterLock = new AutoResetEvent(false); public void Enter() { // Indicate that this thread wants the lock if (Interlocked.Increment(ref m_waiters) == 1) return; // Lock was free, no contention,