递归过程

递归和尾递归 (图解+实例)

1 如果 n=0,n=1f(n)=nf(n) 如果 n>1图1：以递归的方式计算4的阶乘上图（1）展示了利用递归计算4！的过程。

它也说明了递归过程中的两个基本阶段：递推和回归。

在递推阶段，每一个递归调用通过进一步调用自己来记住这次递归过程。

当其中有调用满足终止条件时，递推结束。

比如，在计算n!时，终止条件是当n=1和n=0，此时函数只需简单的返回1即可。

每一个递归函数都必须拥有至少一个终止条件；否则递推阶段永远不会结束了。

一旦递推阶段结束，处理过程就进入回归阶段，在这之前的函数调用以逆序的方式回归，直到最初调用的函数为止，此时递归过程结束。

以递归的方式计算n的阶乘的函数实现：C函数fact的工作方式如下：它接受一个整数n作为参数，如果n小于0，该函数直接返回0，这代表一个错误。

如果n等于0或1，该函数返回1，这是因为0!和1!都等于1，以上是终止递归的条件。

否则，函数返回n-1的阶乘的n倍。

而n-1的阶乘又会以递归的方式再次调用fact来计算，如此继续。

代码实例（1）：fact.c1/*fact.c*/2#include "fact.h"3int fact(int n){4if (n<0)5return0;6else if(n==0)7return1;8else if(n==1)9return1;10else11return n*f(n-1);12}为理解递归究竟是如何工作的，有必要先看看C语言中函数的执行方式。

我们先来看看C程序在内存中的组织方式（见图2-a）。

基本上，一个可执行程序由4个区域组成：代码段、静态数据区、堆与栈。

代码段包含程序运行时所执行的机器指令。

静态数据区包含在程序生命周期内一直持久的数据，比如全局变量和静态局部变量。

堆包含程序运行时动态分配的存储空间，比如malloc分配的内存。

栈包含函数调用的信息。

当C中调用了一个函数时，栈中会分配一块空间来保存与这个调用相关的信息。

汉诺塔递归的过程

汉诺塔递归的过程
汉诺塔递归的过程可以分为以下几个步骤：
1. 基本情况：如果只有一个盘子需要移动，直接将这个盘子从起始柱子移动到目标柱子即可。

2. 递归步骤：将上面的n-1 个盘子从起始柱子通过辅助柱子移动到目标柱子，然后将剩下的最大的盘子直接从起始柱子移动到目标柱子，最后，将之前移动到辅助柱子的n-1 个盘子通过起始柱子移动到目标柱子。

递归的过程中，每一次移动实际上都是在解决一个更小的汉诺塔问题。

具体来说，每当你移动一个盘子时，你实际上是在解决一个有n-1 个盘子的汉诺塔问题，直到只剩下一个盘子，然后再反向操作。

例如，假设有三个盘子（A、B、C），汉诺塔的解法如下：
- 将A（最小盘子）从A 移动到C（辅助柱子）。

- 将B（中等盘子）从A 移动到A（起始柱子）。

- 将A 从C 移动到B（目标柱子）。

- 将B 从A 移动到C。

- 将A 从C 移动到A。

- 将B 从C 移动到B。

- 最后，将A 从A 移动到B。

在这个过程中，每次移动都是在解决一个更小的问题，直到最终解决整个汉诺塔问题。

递归

递归算法
1
递归算法
什么是递归递归调用的实现原理递归经典例题
递归定义

在定义一个过程或函数时出现调用本过程或本函数的成分,称之为递归。若调用自身,称之为直接递归。若过程或函数p调用过程或函数q,而q又调用p,称之为间接递归。
何时用到递归以下三种情况常常用到递归方法。
1 定义是递归的 2 数据结构是递归的 3 问题的解法是递归的
int main() { int a[1000]; f(6,a,0); return 0; }
经典问题：整数划分
要求：如果对上一个题改一下要求，求解一共多少种划分方法，如果不用上一种思路，请再尝试另一种递归解决方案
经典问题：整数划分

整数划分问题是算法中的一个经典命题之一，有关这个问题的讲述在讲解到递归时基本都将涉及。所谓整数划分，是指把一个正整数n写成如下形式： n=m1+m2+...+mi; （其中mi为正整数，并且1 <= mi <= n），则{m1,m2,...,mi}为n的一个划分。如果{m1,m2,...,mi}中的最大值不超过m，即 max(m1,m2,...,mi)<=m，则称它属于n的一个m划分。这里我们记 n的m划分的个数为f(n,m); 例如但n=4时，他有5个划分， {4},{3,1},{2,2},{2,1,1},{1,1,1,1}; 注意4=1+3 和 4=3+1被认为是同一个划分。该问题是求出n的所有划分个数，即f(n, n)。下面我们考虑求f(n,m) 的方法; 1.递归法：
15
f (int a[], int begin, int n) if (begin==n) return 0; else return a[begin]+f(a,begin+1,n);

数据结构之递归

数据结构之递归Ⅲ递归的三⼤要素// 算 n 的阶乘(假设n不为0)int f(int n){if(n <= 2){return n;}}第三要素：找出函数的等价关系式第三要素就是，我们要不断缩⼩参数的范围，缩⼩之后，我们可以通过⼀些辅助的变量或者操作，使原函数的结果不变。

例如，f(n) 这个范围⽐较⼤，我们可以让 f(n) = n * f(n-1)。

这样，范围就由 n 变成了 n-1 了，范围变⼩了，并且为了原函数f(n) 不变，我们需要让 f(n-1) 乘以 n。

说⽩了，就是要找到原函数的⼀个等价关系式，f(n) 的等价关系式为 n * f(n-1)，即f(n) = n * f(n-1)。

这个等价关系式的寻找，可以说是最难的⼀步了，如果你不⼤懂也没关系，因为你不是天才，你还需要多接触⼏道题，我会在接下来的⽂章中，找 10 道递归题，让你慢慢熟悉起来。

找出了这个等价，继续完善我们的代码，我们把这个等价式写进函数⾥。

如下：// 算 n 的阶乘(假设n不为0)int f(int n){if(n <= 2){return n;}// 把 f(n) 的等价操作写进去return f(n-1) * n;}⾄此，递归三要素已经都写进代码⾥了，所以这个 f(n) 功能的内部代码我们已经写好了。

这就是递归最重要的三要素，每次做递归的时候，你就强迫⾃⼰试着去寻找这三个要素。

还是不懂？没关系，我再按照这个模式讲⼀些题。

有些有点⼩基础的可能觉得我写的太简单了，没耐⼼看？少侠，请继续看，我下⾯还会讲如何优化递归。

当然，⼤佬请随意，可以直接拉动最下⾯留⾔给我⼀些建议，万分感谢！Ⅲ案例1：斐波那契数列斐波那契数列的是这样⼀个数列：1、1、2、3、5、8、13、21、34....，即第⼀项 f(1) = 1,第⼆项 f(2) = 1.....,第 n 项⽬为 f(n) = f(n-1) + f(n-2)。

求第 n 项的值是多少。

例详解dns递归和迭代查询原理及过程

例详解
在互联网中，一个域名的顺利解析离不开两类域名服务器，只有由这两类域名服务器可以提供“权威性”的域名解析。
第一类就是国际域名管理机构，也就InterNIC，主要负责国际域名的注册和解析，第二类就是国内域名注册管理机构，在中国就是 CNNIC了，主要负责国内域名注册和解析，当然，尽管分为国际和国内，但两者一主一辅，相互同步信息，毕竟最终的目的是在全球任何一个有网络的地方都可以顺利访问任何一个有效合法的域名，其间的联系就可见一斑了。
我们用dig命令来跟踪一下到网站的整个过程，如下图：
图中提到的gTLD，其实这是顶级域名的一个分类，除此之外还有ccTLD，也就是国家及地区代码顶级域名，即CountryCodeTLD，比如.cn表示中国.hk，表示香港等。上图的4个过程其实就是我们从提交请求，到正常访问的过程。上图中还有很多参数没有说明，这部分会再后面章节有详述。
ftp:///domain/named.root，也可以通过直接从网络上复制。如下图：
在服务器IP地址里，我们可以输入13个地址中的任意一个，确定后系统会自动连接到该服务器上更新列表。也并非13个地址中的一个，如果同网段内有冗余DNS，这里就可以输入那台DNS的地址，也是可以更新的。前提是，两台DNS服务器都必须连接到互联网。当然在DNS的安装目录下的 CACHE.DNS文件中也是可以找到的，具体路径如下：C:\WINDOWS\system32\dns\CACHE.DNS。以上的方法都可以恢复这个列表。
4>本地DNS服务器收到这个地址后，就开始联系对方并将此请求发给他。负责.com域名的某台服务器收到此请求后，如果自己无法解析，就会返回一个管理.com的下一级的DNS服务器地址给本地DNS服务器，也就是负责管理的DNS。

算法复习题

算法复习试题一、名词解释：1、算法：就是一组有穷的规则，它规定了解决某一特定类型问题的一系列运算。

2、贪心算法：能够得到某种量度意义下的最优解的分级处理方法称为贪心算法。

3、分治法：分治法的求解思想就是把整个问题分成若干个小问题后分的治之4、递归过程：一个递归过程的执行类似于多个子程序的嵌套调用，递归过程是自己调用自己本身代码。

递归算法的特点：思路清晰，算法的描述简洁且易理解。

5、集合：在研究某一类对象时，可把这类对象的整体称为集合。

6、生成树：设G=(V,E)是一个无向连通图。

如果G的生成子图T=(V,E')是一棵树，则称T是G的一棵生成树。

7、算法具有以下5个属性：有穷性：一个算法必须总是在执行有穷步之后结束，且每一步都在有穷时间内完成。

确定性：算法中每一条指令必须有确切的含义。

不存在二义性。

只有一个入口和一个出口可行性：就是算法描述的操作是可以通过已经实现的基本运算执行有限次来实现的。

输入：一个算法有零个或多个输入，这些输入取自于某个特定对象的集合。

输出：一个算法有一个或多个输出，这些输出同输入有着某些特定关系的量。

8、迭代法：称辗转法，是一种不断用变量的旧值递推出新值的解决问题的方法。

9、贪婪法: 是一种不追求最优解，只希望得到较为满意解的方法。

贪婪法不要回溯10、动态规划：是一种将问题实例分解为更小的、相似的子问题，并存储子问题的解而避免计算重复的子问题，以解决最优化问题的算法策略。

11、分支限界法：是一种用于求解组合优化问题的排除非解的搜索算法。

12、树：树是一个或多个结点的有限集合。

12、二元树：它是结点的有限集合，它或者为空，或者由一个根和两棵树（左子树和右子树）的不相交的二元树所组成。

13、二分检索树：T是一棵二元树，它或者为空，或者其每个结点含有一个可比较大小的数据元素。

14、图：图是数据结构，一个图G是由称之为结点V和边E的两个集合组成的15、最优解：使目标函数取极值（极大值或极小值）的可行解。

金字塔原理的结构分为

金字塔原理的结构分为
金字塔原理的结构分为四个层次：顶点、递归、块和标断点。

1. 顶点（topline）：顶点是金字塔原理的起点，是整个思维过程的总结。

顶点应该简洁明了地概括出所要表达的中心思想或结论。

2. 递归（recursive）：递归是金字塔原理的核心部分，它通过递归思维的方法将顶点进一步展开为分支，并不断扩展这些分支直至达到详尽的论证要求。

递归的过程一般分为三个步骤：总分总、正反对、核心分析。

3. 块（block）：块是递归过程中的基本单元，是对思想或论点进行具体说明和提供证据支持的最小单位。

一个块应该包括一个主题句和相应的细节或论据，通过堆叠多个块形成整个金字塔结构。

4. 标断点（breakpoints）：标断点用于区分递归过程中不同层次的块或者提醒读者某个重要观点或论证步骤的结束。

标断点可以是空行、缩进或其他明显分隔的方式。

通过这种结构，金字塔原理可以使得作者的思维更加清晰、逻辑更加严密，读者也能更容易理解和掌握作者的观点。

什么是递归

什么是递归？递归（Recursion）是一种编程技术，其中一个函数调用自身来解决问题。

递归是通过将问题分解成更小的子问题来解决复杂问题的一种方法。

这种自我调用的过程在每次调用中都会处理一个更小的问题，直到达到基本情况（终止条件），然后逐步返回结果，最终解决整个问题。

递归的核心思想是将复杂问题分解成更小规模的相同问题。

每次递归调用都会将问题的规模减小，直到问题达到一定的规模，可以直接解决。

这个基本情况通常是一个简单且不再需要递归的情况。

递归的实现通常包括以下几个要素：1. 基本情况：基本情况是递归调用的终止条件。

当问题的规模减小到一定程度，可以直接解决时，递归将停止。

在基本情况下，函数通常直接返回结果而不再进行递归调用。

2. 递归调用：递归函数在解决问题的过程中会调用自身来处理更小规模的子问题。

递归函数通过传递问题的子集或更小的输入来减小问题的规模。

递归调用将重复进行，直到达到基本情况。

3. 问题的规模减小：递归函数通过每次调用将问题的规模减小来逐步解决问题。

这通常涉及到在每次递归调用中使用不同的输入或参数。

问题的规模必须在每次递归调用中减小，否则递归将无法终止，导致无限循环（无穷递归）。

递归的一个典型示例是计算阶乘。

阶乘是指从1到某个正整数之间所有整数的乘积。

使用递归，我们可以将阶乘问题分解为更小的子问题，直到达到基本情况。

例如，计算5的阶乘（5!）可以使用递归的方式来实现：```factorial(n):if n == 0: // 基本情况return 1else:return n * factorial(n-1) // 递归调用```在上面的示例中，当n等于0时，递归调用将停止，返回1作为结果。

否则，函数将n与n-1的阶乘相乘，并继续递归调用，直到达到基本情况。

递归函数需要小心处理，确保递归调用能够终止，并且问题的规模在每次递归调用中减小。

否则，递归可能会导致堆栈溢出或无限循环的问题。

递归在许多算法和数据结构问题中都有应用，例如树的遍历、图的搜索、排序算法等。

递归与递归式

3. 怎么克服递归的效率问题？—化递归为递推
递归：递归是一种从上至下的“分解求解“的过程，即不断地把大问题分解为小问题，直到小问题规模足够小，然后求解并进行递归返回和结果合并。——效率差！
递推：递推是一种从下往上的“合并求解“过程，即从解决小问题出发，记录小问题的答案，并根据已有的小问题的答案，把问题往大里扩展，“滚雪球”，直到达到大问题的规模为止。并通常用迭代（循环）的方式实现，而不是递归调用，一般认为效率上比递归好。
件，称为递归出口，否则会产生死循环而出错。
递归是一种强有力的设计方法与数学模型一致表述简单、清晰、代码量少可读性强、容易证明正确性
递归的问题：执行时间长、运行效率低，特别是占用空间多，容易造成系统栈的溢出。
主要原因：递归调用时有大量的现场保护与恢复操作，在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储，递归层次数过多容易造成栈溢出等。
初始条件：a1=1 用递归公式表示为：an+2=2an+1-an，
初始条件：a1=1，a2=2
这里，没有过于细致地区分递归式与递推式，我们视为一致。
2. 递归式的求解
求解递归式就是化简递归式，以得到形式简单的限界函数表示（即O、Ω、Θ的表示）。
三种常用方法：代换法递归树法主方法
对表达式细节的简化
例如：斐波纳契数列的递推公式为fn=fn-1+fn-2 等差数列递推公式：an=an-1+d 等比数列递推公式：bn=bn-1×q
2) 递归式 Recursion
递归公式：当递推式中只含数列中的项，而无常数项或其它项时，就叫做递归公式。
所以，递归公式属于递推公式的一个特例。例如，自然数列

减数分裂的过程和特点

减数分裂的过程和特点使用增量算法的过程称为减数分裂。

在该过程中，一个数被拆分成其和的一系列较小的数字。

这个过程在计算机科学、数学和其他领域都有应用。

本文将介绍减数分裂的过程和特点。

一、减数分裂的过程减数分裂本质上是一种递归过程。

在许多情况下，彼此相加不可能得出结果，因此需要将数字拆分成较小的数字。

例如，当进行矩阵乘法计算时，需要将矩阵拆分成较小的子矩阵。

减数分裂的过程通常可以通过以下步骤来完成：1. 将要分解的数字拆分成两个数字：a 和 b。

2. 将 a 和 b 分别进行减数分裂，最终得到一个数组。

3. 合并这两个数组，得到拆分后的原始数字。

此过程可以重复多次，拆分成许多较小的数字，直到不能再分解或者达到某个所设定的阈值为止。

二、减数分裂的特点减数分裂有许多有趣的特点。

下面列出其中的一些：1. 减数分裂的时间复杂度是 O(NlogN)。

对于计算机科学中的数据结构和算法，时间复杂度是一个非常重要的性质。

减数分裂的时间复杂度是 O(NlogN)，这意味着随着数据规模的增加，运行时间会相应增加，但是增长速度不会太快。

2. 减数分裂是一种更为优秀的算法。

在许多情况下，减数分裂可以替代传统的算法。

例如，在计算矩阵乘积时，使用减数分裂可以实现更快的计算。

3. 减数分裂可以进行多次递归。

在许多情况下，一次减数分裂无法解决问题，需要进行多次递归。

此递归过程可以在计算过程中进行，每次递归都将将数字拆分成子数字来进行计算。

4. 减数分裂可以使用并发进行。

在计算机科学中，有时候需要并发地进行计算，以提高效率。

减数分裂可以实现并发计算。

将数字拆分成子数字，并使用并发计算，可以得到更快的计算速度。

本文介绍了减数分裂的过程和特点。

减数分裂是一种快速实现计算的方法，具有时间复杂度低、算法优秀、可以递归多次和支持并发计算等特点。

在实际的计算中，可以选择使用减数分裂来提高计算速度。

20个数字选6个的排列组合算法

20个数字选6个的排列组合算法1. 背景介绍在一些数学和计算机科学领域的问题中，经常会涉及到从给定的一组数字中选取特定数量的数字进行排列组合，这种排列组合算法在实际应用中具有重要的意义。

本文将介绍一种针对20个数字选6个的排列组合算法，帮助读者在实际问题中能够灵活应用。

2. 算法原理对于从20个数字中选取6个数字的排列组合，可以采用递归的方式进行计算。

具体步骤如下：3. 步骤一：确定基本数据结构需要确定一个长度为20的数组，表示待选取的数字序列。

设定一个长度为6的数组，用于存储最终选取的6个数字。

另外，设定一个参数k，用于表示当前需要选取的数字的位置。

4. 步骤二：递归计算排列组合通过递归的方式，依次从20个数字中选取6个数字。

具体步骤如下：- 递归终止条件：当需要选取的数字位置k等于6时，表示已经选取了6个数字，将这6个数字输出。

- 递归过程：在第k个位置，可以选择从之前未选择过的数字中选取一个作为当前位置的数字。

然后继续递归，直至选取了6个数字。

5. 算法实现根据上述原理，可以实现20个数字选6个的排列组合算法。

以下是具体的算法实现代码：```pythondefbination(nums, k, start, result, output):if k == 0:output.append(result[:])returnfor i in range(start, len(nums) - k + 1):result.append(nums[i])bination(nums, k - 1, i + 1, result, output)result.pop()def getbinations(nums, k):output = []bination(nums, k, 0, [], output)return output```6. 算法优化以上算法实现基于递归的方式，可以得到从20个数字中选取6个数字的所有排列组合。

递归及递归算法分析课件

A(1,1)=2故A(n,1)=2*n ❖ M=2时，A(n,2)=A(A(n-1,2),1)=2A(n-1,2)，和
A(1,2)=A(A(0,2),1)=A(1,1)=2，故A(n,2)= 2^n 。
2 222
❖ M=3时，类似的可以推出
n
❖ M=4时，A(n,4)的增长速度非常快，以至于没有适当的数学式子来表示这一函数。
❖
move(a,b);
❖
hanoi(n-1, c, b, a);
❖
}
❖}
❖ T(n)=2T(n-1)+O(1) n≥1
T(n)=2n-1
0
n=0
4
27
简单递归式的求解
1.T(n)=T(n-1)+c1 n>1
c2
n=1
2. T(n)=2T(n/2)+c1 n ≥2
c2
n<2
3. T(n)=2T(n/2)+Θ(n) n ≥2
O(1)
n<2
28
T( n/2 ) + T( n/2 ) + 1
例1 T(n) =
0
(n = 1)
解：T(n)=2T(n/2)+1
=22T(n/22)+2+1
=23T(n/23)+22+2+1
令2r=n =2rT(1)+2r-1+。。。+2+1
=(1-2r)/(1-2)=n-1
∴ T( n ) = n - 1
25
递归算法的时间复杂度分析
❖ 递归函数求解
简单递归式求解 master method 递推方程的特征方程求解

递归和尾递归的运行流程解释

递归和尾递归的运⾏流程解释递归和尾递归的运⾏流程解释递归定义递归（英语：recursion）在计算机科学中是指⼀种通过重复将问题分解为同类的⼦问题⽽解决问题的⽅法。

递归式⽅法可以被⽤于解决很多的计算机科学问题，因此它是计算机科学中⼗分重要的⼀个概念。

绝⼤多数编程语⾔⽀持函数的⾃调⽤，在这些语⾔中函数可以通过调⽤⾃⾝来进⾏递归。

计算理论可以证明递归的作⽤可以完全取代循环，因此有很多在函数编程语⾔（如Scheme）中⽤递归来取代循环的例⼦。

(摘⾃维基百科)尾递归定义在计算机学⾥，尾调⽤是指⼀个函数⾥的最后⼀个动作是返回⼀个函数的调⽤结果的情形，即最后⼀步新调⽤的返回值直接被当前函数的返回结果。

此时，该尾部调⽤位置被称为尾位置。

尾调⽤中有⼀种重要⽽特殊的情形叫做尾递归。

经过适当处理，尾递归形式的函数的运⾏效率可以被极⼤地优化。

尾调⽤原则上都可以通过简化函数调⽤栈的结构⽽获得性能优化（称为“尾调⽤消除”），但是优化尾调⽤是否⽅便可⾏取决于运⾏环境对此类优化的⽀持程度如何。

(摘⾃维基百科)前提知识递归我将它分为两个过程,⼀个我将它称为递归,另⼀个我将它称为回溯. 递归的函数的运⾏主要有这两个流程,递归的进⼊,回溯的退出,这两个过程的分界是以递归出⼝为分界的.递归的实现形式是使⽤栈,递归函数的进⼊(递归)类似与压栈,递归函数的退出(回溯)类似于出栈.递归样例和解释【编程题】幂运算三（递归函数）题⽬ID：1137【问题描述】求x^n。

【输⼊形式】⼀⾏2个数，第⼀个整数表⽰x，第⼆个⼤于等于零的整数表⽰n，⼆数之间⽤空格分隔。

【输出形式】⼀⾏⼀个整数，表⽰x的n次⽅【样例输⼊】2 3【样例输出】8【样例说明】2的3次⽅结果为8【评分标准】5组测试⽤例，每组2分，共计10分【测试⽤例】1）输⼊：2 3输出：82）输⼊：3 5输出：2433）输⼊：-17 4输出：835214）输⼊：22 0输出：15）输⼊：-1287 0输出：1//普通递归#include<stdio.h>long my_pow1(long x,int n){if(n==0) return 1; //递归出⼝return x*(my_pow1(x,--n)); //除了调⽤⾃⾝外还乘多了个x,即⼀般的递归}int main(){long x;int n;scanf("%ld%d",&x,&n);printf("%ld\n",my_pow1(x,n));return 0;}运⾏图解解释:普通的递归过程是在⼀个函数中,结果依靠⾃⾝的调⽤来得出,例如求幂运算,pow(2,3)代表求2的3次⽅,由于pow(2,3)未知,我们可以把它分解成2*pow(2,2),pow(2,2)也未知,⼜可分解成2*pow(2,1),以此类推,直到pow(2,0)可知(if中定义0时返回1),即pow(2,0)返回值是1.在这个递归过程中,pow函数的建⽴就是⼀个个压栈的过程我把它称为函数栈压栈压⼊所以函数后,直到最后⼀个,可以获得最后⼀个函数的返回值,由这个返回值可以依次推出栈内所有函数的返回值(回溯),即退栈,pow(2,0)返回1,推的pow(2,1)返回2*pow(2,0),即2*1=2,pow(2,2)返回2*pow(2,1),即2*2=4,直到退到栈内最后⼀个函数pow(2,3),可获得pow(2,3)的返回值为2*pow(2,2)即8;尾递归样例和解释【编程题】吃糖（尾递归函数）题⽬ID：1135【问题描述】⼩樱是个爱吃糖的⼥孩, 哥哥送了她n（1<=n<=30）颗糖，怎么吃？⼀天吃1颗；⼀天吃2颗。

递归调用详解，分析递归调用的详细过程

递归调⽤详解，分析递归调⽤的详细过程⼀、栈在说函数递归的时候，顺便说⼀下栈的概念。

栈是⼀个后进先出的压⼊(push)和弹出(pop)式。

在程序运⾏时，系统每次向栈中压⼊⼀个对象，然后栈指针向下移动⼀个位置。

当系统从栈中弹出⼀个对象时，最近进栈的对象将被弹出。

然后栈指针向上移动⼀个位置。

程序员经常利⽤栈这种数据结构来处理那些最适合⽤后进先出逻辑来描述的编程问题。

这⾥讨论的程序中的栈在每个程序中都是存在的，它不需要程序员编写代码去维护，⽽是由运⾏是系统⾃动处理。

所谓的系统⾃动维护，实际上就是编译器所产⽣的程序代码。

尽管在源代码中看不到它们，但程序员应该对此有所了解。

再来看看程序中的栈是如何⼯作的。

当⼀个函数(调⽤者)调⽤另⼀个函数(被调⽤者)时，运⾏时系统将把调⽤者的所有实参和返回地址压⼊到栈中，栈指针将移到合适的位置来容纳这些数据。

最后进栈的是调⽤者的返回地址。

当被调⽤者开始执⾏时，系统把被调⽤者的⾃变量压⼊到栈中，并把栈指针再向下移，以保证有⾜够的空间存储被调⽤者声明的所有⾃变量。

当调⽤者把实参压⼊栈后，被调⽤者就在栈中以⾃变量的形式建⽴了形参。

被调⽤者内部的其他⾃变量也是存放在栈中的。

由于这些进栈操作，栈指针已经移动所有这些局部变量之下。

但是被调⽤者记录了它刚开始执⾏时的初始栈指针，以他为参考，⽤正或负的偏移值来访问栈中的变量。

当被调⽤者准备返回时，系统弹出栈中所有的⾃变量，这时栈指针移动了被调⽤者刚开始执⾏时的位置。

接着被调⽤者返回，系统从栈中弹出返回地址，调⽤者就可以继续执⾏了。

当调⽤者继续执⾏时，系统还将从栈中弹出调⽤者的实参，于是栈指针回到了调⽤发⽣前的位置。

可能刚开始学的⼈看不太懂上⾯的讲解，栈涉及到指针问题，具体可以看看⼀些数据结构的书。

要想学好编程语⾔，数据结构是⼀定要学的。

⼆、递归递归，是函数实现的⼀个很重要的环节，很多程序中都或多或少的使⽤了递归函数。

递归的意思就是函数⾃⼰调⽤⾃⼰本⾝，或者在⾃⼰函数调⽤的下级函数中调⽤⾃⼰。

递归算法

问题分析：我们根据给出的样例可知：每次输出的结果都是由前一次的结果变化而来的，也就是问题每推进一步其结果仍维持与原问题的关系，可见采用递归算法比较合适。其算法的大致过程如下： 1、利用循环语句实现对前一次的输出结果从后向前找一个a[i]，使得a[i]到a[w]的字符都在s、t规定的字母范围内，以确定本次的输出结果。 2、当输出结果达到5个，结束递归；如果没那么多 Jam数字，当第一次被入栈的循环结束时，递归结束。

上楼梯问题
递归关系： f(1)=1; f(2)=2; f(n)=f(n-1)+f(n-2); (n≥3)

已知:ack(m,n)函数的计算公式如下:
请计算ack(m,n)的值。(m,n<=5)
用递归算法求解两个整数的最大公约数

分析：辗转相除法。即：两个整数相除，看其余数是否为0。若余数为0，则除数即为所求最大公约数；若余数不为0，就将除数作为被除数，余数作为除数，继续相除，循环往复，直到余数为0。
数的计算

问题描述我们要求找出具有下列性质数的个数(包含输入的自然数n): 先输入一个自然数n(n<=1000),然后对此自然数按照如下方法进行处理: 1. 不作任何处理; 2. 在它的左边加上一个自然数,但该自然数不能超过原数的一半; 3. 加上数后,继续按此规则进行处理,直到不能再加自然数为止. 样例: 输入: 6 满足条件的数为 6 (此部分不必输出) 16 26 126 36 136 输出: 6

问题分析：对于这个问题，首先，我们得具备对一颗二叉树能熟练并且正确写出它的前序、中序、后序序列的能力，才能编写程序解决问题。我们根据题中给出的中序及后序序列，可以找出该树根结点及左右子树。同样对于左右子树，再根据它们各自的中序及后序序列，又能找出它们的根结点及它们的左右子树。由此可见，该问题能够被递归描述。当最后的序列为空时，递归无法再进行下去，就是递归结束的边界条件。

第6章递归

第6章递归
用递归方法分析考虑如下。设盘子的总数为n，我们给A柱上的盘子从上至下编号为１到ｎ。当n=1时，问题可直接求解，即我们可直接把A柱上的盘子移到 C柱上；当n>1时，移动由以下三步组成：（１）用C柱做过渡把A柱上的ｎ－１个盘子移到Ｂ柱上；（２）把A柱上的最后一个盘子移到Ｃ柱上；（３）用Ａ柱做过渡把Ｂ柱上的ｎ－１个盘子移到Ｃ柱上。
第6章递归
*6.5 转化递归算法为非递归算法
总结我们本章至此讨论过的递归算法，可得出递归算法的两个特性：（1）递归算法是一种分而治之的、把复杂问题分解为简单问题的求解问题方法，对求解某些复杂问题，递归算法分析问题的方法是十分有效的。（2）递归算法的时间效率通常非常差，其时间效率经常是实际应用中不可忍受的。
第6章递归
另一个典型的例子是汉诺塔问题的求解。汉诺塔问题是：设有3根标号为A，B，C的柱子，在A柱上放着n个盘子，每一个都比下面的略小一点，要求把A柱上的盘子全部移到C柱上。移动的规则是：（1）一次只能移动一个盘子；（2）移动过程中大盘子不能放在小盘子上面；（3）在移动过程中盘子可以放在A，B， C的任意一个柱子上。
第6章递归
6.5.1 尾递归和单向递归的消除尾递归是递归调用语句只有一个，而且是处于算法的最后。以阶乘问题的递归算法Fact(n)为例讨论尾递归算法的运行过程。为讨论方便，我们再次列出阶乘问题的递归算法Fact(n)，并简化掉参数n的出错检查语句，改写递归调用语句的位置在最后，算法如下： long Fact(int n) { if(n==0)return1; return n*Fact(n-1); }
第6章递归
分析上述算法可以发现，当递归调用返回时，返回到上一层递归调用的下一语句，而这个返回位置正好是算法的末尾。也就是说，以前每次递使用。因此，对于尾递归形式的递归算法，不必利用系统的运行时栈保存各种信息。尾递归形式的算法实际上可变成循环结构的算法。循环结构的阶乘问题算法Fact2(n)如下：