递归

科赫曲线 ——————————— 绘制科赫曲线 import turtle def koch ( size , n ) : if n == 0 : turtle . fd ( size ) else : for angle in [ 0 , 60 , - 120 , 60 ] : turtle . left ( angle ) koch ( size / 3 , n - 1 ) def main ( level ) : turtle . setup ( 600 , 600 ) turtle . penup ( ) turtle . goto ( - 200 , 100 ) turtle . pendown ( ) turtle . pensize ( 2 ) turtle . hideturtle ( ) try : level = eval ( input ( "请输入科赫曲线的阶: " ) ) main ( level ) except : print ( "输入错误" ) 绘制科赫雪花 import turtle def koch ( size , n ) : if n == 0 : turtle . fd ( size ) else : for angle in [ 0 , 60 , - 120 , 60 ] : turtle . left ( angle ) koch (

本文转载自作者：hzhu212 链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/yan-se-biao-ji-fa-yi-chong-tong-yong-qie-jian-ming/ 来源：力扣（LeetCode） 官方题解中介绍了三种方法来完成树的中序遍历，包括： 递归 借助栈的迭代方法 莫里斯遍历 在树的深度优先遍历中（包括前序、中序、后序遍历），递归方法最为直观易懂，但考虑到效率，我们通常不推荐使用递归。 栈迭代方法虽然提高了效率，但其嵌套循环却非常烧脑，不易理解，容易造成“一看就懂，一写就废”的窘况。而且对于不同的遍历顺序（前序、中序、后序），循环结构差异很大，更增加了记忆负担。 因此，我在这里介绍一种“颜色标记法”（瞎起的名字……），兼具栈迭代方法的高效，又像递归方法一样简洁易懂，更重要的是，这种方法对于前序、中序、后序遍历，能够写出完全一致的代码。 其核心思想如下： 使用颜色标记节点的状态，新节点为白色，已访问的节点为灰色。 如果遇到的节点为白色，则将其标记为灰色，然后将其右子节点、自身、左子节点依次入栈。 如果遇到的节点为灰色，则将节点的值输出。 使用这种方法实现的中序遍历如下： class Solution : def inorderTraversal ( self

#include "stdio.h" long recursion(int n); void main() { int n; long result; printf("input a integer number:"); scanf("%d",&n); result=recursion(n); printf("%d!=%ld\n",n,result); } long recursion(int n) { long temp_result; if(n<0) { printf("录入错误n应大于0！"); } else if(n==0||n==1) { temp_result=1; } else { temp_result=recursion(n-1)*n; } return temp_result; } 来源： https://www.cnblogs.com/zyz322/p/12309452.html

问题描述： 斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： F(0) = 0, F(1) = 1 F(N) = F(N - 1) + F(N - 2), 其中 N > 1. 给定 N，计算 F(N)。 示例 ： 输入：2 输出：1 解释：F(2) = F(1) + F(0) = 1 + 0 = 1. 问题分析： 由于计算任何一个第n(n >= 2)项的数都需要知道其前面两个数，即需要知道n-1和n-2是多少，然后两个相加得到结果，但是问题来了，要知道n-1，就要需要知道n-2，要知道n-2就需要知道n-3，会一直这样的循环递归下去，一直到第一个数，第二个，第三个.......再反推回来。 那就很明显了，大家第一时间想到的方法便是递归，就下来实现一下： 方法一：递归实现 public class Solution { public int fib(int n) { if(n <= 1){ return n; } return fib(n-1) + fib(n-2); } } ​ 问题分析： ​ 先看一下递归图： ​ 由于很多数的计算都要重复很多次，效率并不高，时间复杂度达到了 O（2^n），是斐波那契数计算中 时间复杂度最大，最不可取的方法。 ​ 空间复杂度：O（n）,堆栈中需要的空间与 N

一、二叉搜索树Binary Search Tree 1、若左子树不为空，则左子树上所有节点的值均小于或等于它的根节点的值。 2、若右子树不为空，则右子树上所有节点的值均大于或等于它的根节点的值。 3、左、右子树也分别为二叉搜索树。 二、节点域设置 //根节点 private Entry < T > root ; //初始化 public BSTDemo ( ) { this . root = null ; } //节点域 public class Entry < T extends Comparable < T > > { private T data ; //数据域 private Entry < T > left ; //左孩子域 private Entry < T > right ; //右孩子域 public Entry ( ) { this ( null , null , null ) ; } public Entry ( T data , Entry < T > left , Entry < T > right ) { this . data = data ; this . left = left ; this . right = right ; } } 三、递归和非递归操作BST 1、插入 （1）递归插入 //插入 public void insert ( T val

1 /*23 【程序 23 求岁数】 2 题目：有 5 个人坐在一起，问第五个人多少岁，他说比第 4 个人大 2 岁。问第 4 个人岁数，他说比第 3 个 3 人大 2 岁。问第三个人，又说比第 2 人大两岁。问第 2 个人，说比第一个人大两岁。最后问第一个人，他 4 说是 10 岁。请问第五个人多大？ 5 */ 6 7 /*分析 8 *除第一个人外，每个人都比前面那个人大2岁，用递归算法 9 *x2=x1+2,x3=x2+2,x4=x3+2,x5=x4+2;x1=10 10 * */ 11 12 13 package homework; 14 15 public class _23 { 16 17 public static void main(String[] args) { 18 // 第一个人10岁，共5人 19 int years=10; 20 int x=5; 21 System.out.println("第"+x+"个人的年龄为："+NianLing(years, x)+"岁"); 22 } 23 public static int NianLing(int y,int x) { 24 if(x==1) { 25 return y; 26 } 27 else { 28 x--; 29 return NianLing(y, x)+2; 30 } 31 } 32 33 }

递推，递归与分治 递推 什么是递推 递推，就是从小的解开始，一步一步推到最优解的过程。 如何递推 这就要看具体情况，想出递推式，然后一步一步递推即可。 递推如何应用 讲这个之前，我们不妨先讲一讲递推如何具体实现。 第一步是先 初始化 。切记！ 有两种表示方法： 数组递推法，如 f[i] = f[i-1]+f[i-2]; 记忆化搜索，若冗余状态比较多则需要记忆化，否则直接调用即可。注意递归的结束，否则MLE或TLE后果自负。 那么，什么是冗余状态呢？ 这是一个关于f(5)的解答树，可以看见，红色的都是被重复计算的，很多节点被重复计算了多次，若数比较大，重复计算的可不止这几个，而是一颗巨大的子树。 我们在计算时用数组记录已经算出的结果，就是记忆化搜索的核心思想。 来源： https://www.cnblogs.com/lhy-cblog/p/12306015.html

@(Java ThirdParty)[Struts|Interceptor] Struts2 拦截器配置以及实现 Struts2的拦截器应用于Action，可以在执行Action的方法之前，之后或者两者。用于处理一些公共的方法，而不影响原有的代码，并且使得可以关注功能的实现，分离关注点。比如防止重复提交等。 如下图（图片来自Struts2文档Interceptor章节）： 拦截器配置 注： 以下配置均来自于Struts2官方的例子 Struts2内置了一些拦截器，也可以通过实现 Interceptor 接口来自定义拦截器。 如下，在struts.xml中配置自定义拦截器以及引用定义的拦截器： <package name="default" extends="struts-default"> <interceptors> <interceptor name="timer" class=".."/> </interceptors> <action name="login" class="tutorial.Login"> <interceptor-ref name="timer"/> <result name="input">login.jsp</result> </action> </package> 如果定义多个拦截器，像上面那样一个个引用显然是很费劲的

1.自旋锁定义 自旋锁是转为防止多处理器并发而引入的一种锁，它在内核中大量应用与中断处理等部分（对于单处理器，防治中断处理的并发可简单采用关闭中断的方式，即在标志寄存器中关闭/打开中断标志位，不需要自旋锁）。自旋锁与互斥锁的区别：（1）对于互斥所，若资源已被占用，资源申请者只能进入睡眠状态；（2）但自旋锁不会引起调用者睡眠，若自旋锁已被别的执行单元保持，调用者就一直循环查看是否该自旋锁的保持者已释放了锁。 2.原理 跟 互斥锁 一样，一个执行单元要想访问被自旋锁保护的 共享资源 ，必须先得到锁，在访问完共享资源后，必须释放锁。如果在获取自旋锁时，没有任何执行单元保持该锁，那么将立即得到锁；如果在获取自旋锁时锁已经有保持者，那么获取锁操作将自旋在那里，直到该自旋锁的保持者释放了锁。 3.存在的问题 （1） 死锁 。试图递归地获得自旋锁必然会引起 死锁 ：递归程序的持有实例在第二个实例循环，以试图获得相同自旋锁时，不会释放此自旋锁。在递归程序中使用自旋锁应遵守下列策略：递归程序决不能在持有自旋锁时调用它自己，也决不能在 递归调用 时试图获得相同的自旋锁。此外如果一个进程已经将资源锁定，那么，即使其它申请这个资源的进程不停地疯狂“自旋”,也无法获得资源，从而进入 死循环 。 （2）过多占用 cpu 资源。如果不加限制，由于申请者一直在循环等待，因此自旋锁在锁定的时候,如果不成功,不会睡眠

题解： #include<iostream> using namespace std; int ret=0,m_n; void p(int n,double k,int j){ if(k==1){ if(n>=j){ ret++; return; }else{ return; } } for(int i=j;i<=m_n/k;i++){ p(n-i,k-1,i); } return; } int main() { double k; cin>>m_n>>k; p(m_n,k,1); cout<<ret<<endl; return 0; } 来源： https://www.cnblogs.com/lijiahui-123/p/12302660.html