递归函数

lambda 匿名函数 　　语法 lambda 参数;返回值 a = lambda n : n * n print(a) #n = 2 #4 s = lambda x,y:x,y print(s) #这个会报错，默认认为 x,y:x 是一对元组，y 没有传值，会报错 s = lambda x,y:(x,y) print(s) #用括号括起来说明这是一个整体，就ok sorted() 排序函数 　　内置函数中提供了一个通用的排序方案 　　 lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"] def func(): ruturn len(lst) % 2 li = sorted(lst,key = func) print(li) # 聊斋 三国演义 年轮 亮剑 西游记 葫芦娃 水浒传 lst = [ {'name':"汪峰","age":48}, {"name":"章子怡",'age':38}, {"name":"alex","age":39}, {"name":"wusir","age":32}, {"name":"赵一宁","age":28} ] li = dorted(lst,key = lambda el : len(el['name'])) print(li) #{'name': 'wusir', 'age': 32},

　　递归就是函数直接或者是间接的调用自己，相当于循环，使用时必需要有一个跳出条件，否则会进入死循环。它是栈的存取方式，先进后出，后进先出。 　　主要用于循环，如阶乘函数、幂函数和斐波那契数列。 <script> function fn(n) { if (n == 1) { return n; } return fn(n - 1) + n; } console.log(fn(5)); //15 </script> 　　以下为分析过程： <script> //分析： n = 5 function fn(5) { if (5 === 1) { //不满足 return n; } return fn(4) + 5; //10+5=15 } n = 4 function fn(4) { if (4 === 1) { //不满足 return n; } return fn(3) + 4; //6+4=10 } n = 3 function fn(3) { if (3 === 1) { //不满足 return n; } return fn(2) + 3; //3+3=6 } n = 2 function fn(2) { if (2 === 1) { //不满足 return n; } return fn(1) + 2; //1+2=3 } n = 1 function fn(1) { if

题目：求1+2+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字以及条件判断语句（A?B:C). 使用函数指针 1234567891011121314151617 //使用函数指针 递归加法typedef (*fun)(int);int func1(int n) { return 0;}int func2(int n) { fun f[2] = {func1, func2}; return n + f[(n != 0)](n - 1);}void function1() { cout << func2(10) << endl;}//----->fun2 end 使用静态变量 1234567891011121314151617181920212223242526272829 //----->fun2 start//使用静态变量class test { static int N; static int sum;public : test() { sum += ++N; } static void reset() { N = sum = 0; } static int getSum() { return sum; }};int test::N = 0;int test::sum = 0;void function2() { test:

几道基础C语言题 1.递归求阶乘 分析 ： n!=1*2*...*n 那么我们有两种方法 递归 思路 ：根据阶乘的规律 n！=n*（n-1）！ 定义函数f（x），使函数返回 x*f（x-1） 的值，直到n=1。经过函数调用本身求出结果。 代码 ： #include<stdio.h> int cnt(int n);//调用声明函数 int main() { int n; scanf("%d",&n); printf("%d",cnt(n)); return 0; } int cnt(int n)//定义声明函数 { if(n>0) n*=cnt(n-1); else n=1; return n; } 循环 思路 ：由于 n！=n*(n-1)*...*1 ，则从a=1开始，+1之后与a相乘。 代码 ： #include<stdio.h> int main() { int n; scanf("%d",&n); int a=1; //a要初始化为1 for(int i=1;i<=n;i++) //注意i应从1取到n，因此判断条件为<= a=a*i; printf("%d",a); return 0; } 2.分制转换 题目 ：给出一个百分制成绩，要求输出成绩等级‘A’（90分及90分以上），‘B’（80到89分），’C’（70到79分），’D’（60到69分），’E’（60分以下）。

1. 介绍 动态规划典型的被用于优化递归算法，因为它们倾向于以指数的方式进行扩展。动态规划主要思想是将复杂问题（带有许多递归调用）分解为更小的子问题，然后将它们保存到内存中，这样我们就不必在每次使用它们时重新计算它们。 要理解动态规划的概念，我们需要熟悉一些主题： 什么是动态规划？ 贪心算法 简化的背包问题 传统的背包问题 Levenshtein Distance LCS-最长的共同子序列 利用动态规划的其他问题 结论 本文所有代码均为 java 代码实现。 2. 什么是动态规划？ 动态规划是一种编程原理，可以通过将非常复杂的问题划分为更小的子问题来解决。这个原则与递归很类似，但是与递归有一个关键点的不同，就是每个不同的子问题只能被解决一次。 为了理解动态规划，我们首先需要理解递归关系的问题。每个单独的复杂问题可以被划分为很小的子问题，这表示我们可以在这些问题之间构造一个递归关系。 让我们来看一个我们所熟悉的例子： 斐波拉契数列 ，斐波拉契数列的定义具有以下的递归关系： 注意：递归关系是递归地定义下一项是先前项的函数的序列的等式。 Fibonacci 序列就是一个很好的例子。 所以，如果我们想要找到斐波拉契数列序列中的第n个数，我们必须知道序列中第n个前面的两个数字。 但是，每次我们想要计算 Fibonacci 序列的不同元素时，我们在递归调用中都有一些重复调用，如下图所示

暴力递归就是尝试 1, 把问题转化为规模缩小了的同类问题的子问题 2, 有明确的不需要继续进行递归的条件(base case) 3, 有当得到了子问题的结果之后的决策过程 4, 不记录每一个子问题的解 一定要学会怎么去尝试，因为这是动态规划的基础，这一内容我们将在提升班讲述 汉诺塔问题 打印n层汉诺塔从最左边移动到最右边的全部过程 public static void hanoi(int n) { if (n > 0) { func(n, "左", "右", "中"); } } // 1~i 圆盘 目标是from -> to， other是另外一个 public static void func(int N, String from, String to, String other) { if (N == 1) { // base System.out.println("Move 1 from " + from + " to " + to); } else { func(N - 1, from, other, to); System.out.println("Move " + N + " from " + from + " to " + to); func(N - 1, other, to, from); } } 打印一个字符串的全部子序列，包括空字符串 public static

编程实现合并两个有序(假定为降序)单链表的函数，输入为两个有序链表的头结点，函数返回合并后新的链表的头节点， 要求：不能另外开辟新的内存存放合并的链表。 递归方式： /* * 递归方式 */ public LinkNode MergeLinkList(LinkNode head1,LinkNode head2){ if(head1 == null) return head2; if (head2 == null) return head1; LinkNode mergeHead = null; if(head1.value < head2.value){ mergeHead = head1; mergeHead.next = MergeLinkList(head1.next,head2); } else { mergeHead = head2; mergeHead.next = MergeLinkList(head1,head2.next); } return mergeHead; } 非递归方式： /* * 非递归方式 */ public LinkNode MergeLinkList_1(LinkNode head1,LinkNode head2){ if(head1 == null) return head2; if (head2 == null) return head1;

问题描述： 　　一个栈依次压入1,2,3,4,5那么从栈顶到栈底分别为5,4,3,2,1。将这个栈转置后，从栈顶到栈底为1,2,3,4,5，也就是实现栈中元素的逆序，但是只能用递归函数来实现，而不能用另外的数据结构。 实现代码： #include <stack> #include <stdio.h> using namespace std; int GetAndRemoveBottom(stack<int> &ss) { int top, bottom; top = ss.top(); ss.pop(); if(ss.empty()) return top; bottom = GetAndRemoveBottom(ss); ss.push(top); return bottom; } void ReverseStack(stack<int> &ss) { if(ss.empty()) return ; int bottom = GetAndRemoveBottom(ss); ReverseStack(ss); ss.push(bottom); } int main() { stack<int> ss; for(int i = 1; i <= 5; i++) ss.push(i); ReverseStack(ss); while(!ss.empty()) { printf("%d "

用到两个函数ParseDirectory 和CreatePathList void ParseDirectory( string path, string filter) { string [] dirs = Directory.GetDirectories(path); // 得到子目录 IEnumerator iter = dirs.GetEnumerator(); while (iter.MoveNext()) { string str = ( string )(iter.Current); ParseDirectory(str, filter); } string [] files = Directory.GetFiles(path, filter); if (files.Length > 0 ) { m_numFiles += files.Length; m_pathList.Add(files); } } string [] CreatePathList() { if (m_numFiles <= 0 ) { return null ; } string [] str = new string [m_numFiles]; int index = 0 ; try { IEnumerator pathIter = m_pathList.GetEnumerator();

动态规划 Dynamic Programming 一种设计的技巧，是解决一类问题的方法 dp遵循固定的思考流程：暴力递归 —— 递归+记忆化 —— 非递归的动态规划（状态定义+转移方程） 斐波那契数列 暴力递归，看上去很简洁 def fib(n): return n if n <= 1 else fib(n-1) + fib(n-2) 画出递归树分析一下，可以很容易发现有很多重复计算。 重叠子问题 。 递归算法的时间复杂度怎么计算？ 子问题个数乘以解决一个子问题需要的时间。显然，斐波那契数列的递归解法时间复杂度为O(2 n * 1)，暴力递归解法基本都会超时。 如何解决？ 递归 + 记忆化 仍然使用递归，不同点在于，如果重叠子问题已经计算过，就不用再算了，相当于对冗余的递归树进行了剪枝。 由于不存在重叠子问题，时间复杂度为O(n * 1)，降到线性。 1 class Solution: 2 def Fibonacci(self, n): 3 # write code here 4 if n <= 1: 5 return n 6 memo = [-1] * (n+1) 7 memo[0], memo[1]= 0, 1 8 9 def helper(n, memo): 10 if memo[n] >= 0: 11 return memo[n] 12 memo[n] = helper(n