45递归算法与递归顺序
简述递归算法的执行过程
简述递归算法的执行过程摘要：1.递归算法的定义和基本原理2.递归算法的执行过程3.递归算法的应用实例4.递归算法的时间复杂度和优化方法5.总结正文：递归算法是一种自调用算法，通过将问题分解为更小的子问题来解决问题。
它在计算机科学和数学领域中广泛应用，具有可读性和实用性。
下面详细介绍递归算法的执行过程、应用实例、时间复杂度和优化方法。
一、递归算法的定义和基本原理递归算法是一种算法，它通过将问题分解为更小的子问题来解决问题。
这些子问题与原始问题具有相似的特征，从而使得算法可以通过重复调用自身来解决这些子问题。
在递归算法中，有一个基本情况（base case）和递归情况（recursive case）。
基本情况是问题规模足够小，可以直接给出答案的情况；递归情况则是将问题分解为更小的子问题，并重复调用算法本身来解决这些子问题。
二、递归算法的执行过程1.初始化：定义问题的初始条件，通常是基本情况。
2.判断基本情况：如果问题规模足够小，直接给出答案。
3.划分问题：将问题分解为更小的子问题，并确保这些子问题与原始问题具有相似的特征。
4.递归调用：将子问题传递给算法本身，重复执行步骤1-3，直到基本情况出现。
5.合并结果：将递归调用返回的结果合并，得到最终答案。
三、递归算法的应用实例1.计算阶乘：递归算法可以用于计算一个正整数的阶乘。
例如，计算5的阶乘：```def factorial(n):if n == 0:return 1else:return n * factorial(n-1)```2.计算Fibonacci 数列：递归算法可以用于计算Fibonacci 数列。
例如，计算第n个Fibonacci 数：```def fibonacci(n):if n == 0:return 0elif n == 1:return 1else:return fibonacci(n-1) + fibonacci(n-2)```四、递归算法的时间复杂度和优化方法1.时间复杂度：递归算法的时间复杂度通常为O(2^n)，其中n为问题的规模。
递归算法原理
递归算法原理
递归是一种算法设计技巧，它的原理是通过将一个问题分解成一个或多个规模较小但类似于原问题的子问题来解决。
递归算法通过反复调用自身来解决这些子问题，直到子问题的规模足够小并可以直接解决为止。
递归算法的主要思想是将问题转化为更小的同类问题的子问题，并在每一次递归调用中将问题的规模减小。
递归算法需要定义一个基准情况，即问题的最小规模情况，当问题达到基准情况时，递归的调用将停止，得到最终的解。
当使用递归算法时，需要注意以下几点：
1. 递归的结束条件：为了避免无限递归，递归函数必须定义结束条件，即基准情况。
2. 递归调用：在函数内部调用自身来解决规模较小的子问题。
3. 子问题规模的减小：每次递归调用时，子问题的规模应该比原问题要小。
4. 递归栈：在每次递归调用时，系统会将当前的函数调用信息存储在递归栈中，当递归调用结束后，系统将会按照递归栈的顺序逐个弹出函数调用信息，直到返回最终的解。
递归算法在解决某些问题时非常有效，例如树和图的遍历、排列组合、分治算法等。
然而，递归算法也存在一些缺点，例如
递归调用会消耗较多的内存空间和时间复杂度较高等问题，因此在实际应用中需要根据具体情况来选择是否使用递归算法。
递归算法及经典递归例子代码实现
递归算法及经典递归例子代码实现递归算法是一种在函数体内调用函数本身的算法。
通过递归，问题可以被分解为规模更小的子问题，直到达到基本情况，然后将所有的子问题的解合并起来，得到原始问题的解。
递归算法的实现通常包含两个要素：基本情况和递归调用。
基本情况是指不能再进一步分解的情况，一般是针对问题的最小输入。
递归调用是指在解决子问题之后，将问题规模缩小，然后调用自身来解决更小规模的问题。
下面将介绍三个经典的递归例子，并给出相应的代码实现。
1.阶乘计算：阶乘是指从1到给定的数字n之间所有整数的乘积。
它是递归问题的经典例子之一```pythondef factorial(n):if n == 0:return 1else:return n * factorial(n - 1)```在阶乘的递归实现中，基本情况是n等于0时，返回1、递归调用是将问题规模变为n-1，然后将得到的结果与n相乘。
通过递归调用，可以一直计算到n为1，然后将每个阶乘结果逐步合并返回，最终得到n的阶乘。
2.斐波那契数列：斐波那契数列是指从0和1开始，后续的数字都是前两个数字之和。
```pythondef fib(n):if n <= 0:return 0elif n == 1:return 1else:return fib(n - 1) + fib(n - 2)```在斐波那契数列的递归实现中，基本情况是n小于等于0时返回0，n等于1时返回1、递归调用是将问题规模分为两个子问题，分别计算n-1和n-2的斐波那契数，然后将两个子问题的结果相加返回。
通过递归调用，可以一直计算到n为0或1，然后将每个斐波那契数逐步合并返回，最终得到第n个斐波那契数。
3.二叉树遍历：二叉树遍历是指按照一定的顺序访问二叉树的所有节点。
```pythonclass TreeNode:def __init__(self, val=0, left=None, right=None):self.val = valself.left = leftself.right = rightdef inorderTraversal(root):if root is None:return []else:return inorderTraversal(root.left) + [root.val] + inorderTraversal(root.right)```在二叉树的中序遍历的递归实现中，基本情况是判断当前节点是否为空，如果为空则返回一个空列表。
递归算法详解完整版
递归算法详解完整版递归算法是一种重要的算法思想，在问题解决中起到了很大的作用。
它通过将一个大问题划分为相同或类似的小问题，并将小问题的解合并起来从而得到大问题的解。
下面我们将详细介绍递归算法的定义、基本原理以及其应用。
首先，我们来定义递归算法。
递归算法是一种通过调用自身解决问题的算法。
它通常包括两个部分：基础案例和递归步骤。
基础案例是指问题可以被直接解决的边界情况，而递归步骤是指将大问题划分为较小问题并通过递归调用自身解决。
递归算法的基本原理是"自顶向下"的思维方式。
即从大问题出发，不断将问题划分为较小的子问题，并解决子问题，直到达到基础案例。
然后将子问题的解合并起来，得到原始问题的解。
递归算法的最大特点是简洁而优雅。
通过将复杂问题分解为简单问题的解决方式，可以大大减少代码的复杂程度，提高程序的效率和可读性。
但是递归算法也有一些缺点，包括递归深度的限制和复杂度的不确定性。
过深的递归调用可能导致栈溢出，而不合理的递归步骤可能导致复杂度过高。
递归算法有许多应用场景，我们来介绍其中一些典型的应用。
1.阶乘问题：计算一个数的阶乘。
递归算法可以通过将问题划分为更小的子问题来解决。
例如，n的阶乘可以定义为n乘以(n-1)的阶乘。
当n 等于1时，我们可以直接返回1作为基础案例。
代码如下：```int factorial(int n)if (n == 1)return 1;}return n * factorial(n - 1);```2.斐波那契数列问题：求斐波那契数列中第n个数的值。
斐波那契数列的定义是前两个数为1，然后从第三个数开始，每个数都是前两个数的和。
递归算法可以通过将问题划分为两个子问题来解决。
当n等于1或2时，直接返回1作为基础案例。
代码如下：```int fibonacci(int n)if (n == 1 ， n == 2)return 1;}return fibonacci(n - 1) + fibonacci(n - 2);```3.二叉树问题：对于给定的二叉树，递归算法可以通过递归调用左子树和右子树的解来解决。
6种基本算法 递归
6种基本算法递归递归是一种重要的算法思想，它在计算机科学中得到广泛应用。
本文将介绍六种基本的递归算法，并对其原理和应用进行讲解。
一、递归的基本概念递归是指一个函数在其定义中调用自身的过程。
递归算法通过将一个大问题划分为一个或多个相同或相似的子问题，然后通过解决子问题来解决原始问题。
递归算法具有简洁、优雅以及可读性强的特点，但同时也需要注意递归的停止条件，以避免无限递归的发生。
二、阶乘算法阶乘算法是递归算法中最经典的例子之一。
它的定义如下：```n! = n * (n-1) * (n-2) * ... * 1```其中，n为一个非负整数。
阶乘算法可以通过递归的方式实现，即：```fact(n) = n * fact(n-1)```其中，停止条件为`n=0`时，返回1。
三、斐波那契数列算法斐波那契数列是一个无限序列，其定义如下：```F(0) = 0F(1) = 1F(n) = F(n-1) + F(n-2) (n>1)```斐波那契数列算法可以通过递归的方式实现，即：```fib(n) = fib(n-1) + fib(n-2)```其中，停止条件为`n=0`或`n=1`时，返回相应的值。
四、二分查找算法二分查找算法是一种高效的查找算法，它的基本原理是将已排序的数组分成两部分，然后判断目标值在哪一部分，并继续在该部分中进行查找，直到找到目标值或者查找范围为空。
二分查找算法可以通过递归的方式实现，即：```binarySearch(arr, target, start, end) = binarySearch(arr, target, start, mid-1) (target < arr[mid])= binarySearch(arr, target, mid+1, end) (target > arr[mid])= mid (target = arr[mid])```其中，`arr`为已排序的数组，`target`为目标值，`start`和`end`为查找范围的起始和结束位置。
常见递归算法
常见递归算法
常见的递归算法包括以下几种：
1. 斐波那契数列：斐波那契数列是一个经典的递归问题，每个数都是前两个数的和。
通过递归可以很容易地计算出斐波那契数列的每一项。
2. 树的遍历：在树的遍历中，递归是一种常见的实现方式。
例如，前序遍历、中序遍历和后序遍历都可以通过递归算法来实现。
3. 汉诺塔问题：汉诺塔问题是一个经典的递归问题，需要将一系列圆盘从一个柱子移动到另一个柱子，且在移动过程中不能将较大的圆盘放在较小的圆盘上面。
递归算法可以有效地解决这个问题。
4. 快速排序算法：快速排序是一种常用的排序算法，它采用了分治法的思想，通过递归将数组分成两部分并对其进行排序。
5. 归并排序算法：归并排序也是一种基于分治思想的排序算法，通过递归将数组分成子数组，然后合并它们以得到排序后的数组。
6. 二分查找算法：二分查找是一种在有序数组中查找特定元素的高效算法。
通过将数组一分为二并递归地在子数组中查找，可以快速缩小查找范围。
7. Tower of Hanoi（汉诺塔）问题：这是一个经典的数学谜题，需要将一系列圆盘从一个柱子移动到另一个柱子，遵循特定的规则。
递归算法可以用来解决这个问题。
这些只是一些常见的递归算法示例，递归在很多其他问题和算法中也有广泛应用。
递归的优点是代码简洁易懂，但需要注意防止递归深度过大导致栈溢出等问题。
在实际应用中，需要根据具体情况选择合适的算法和数据结构来解决问题。
递归算法 冒泡排序
递归算法冒泡排序冒泡排序是一种经典的排序算法，它通过重复地交换相邻两个元素的位置来实现排序。
在这个算法中，较大的元素会逐渐“浮”到数组的尾部，因此得名冒泡排序。
冒泡排序的思想非常简单，它的基本步骤如下：1. 从数组的第一个元素开始，比较相邻的两个元素的大小。
2. 如果前一个元素大于后一个元素，则交换它们的位置。
3. 继续比较下一个相邻的元素，重复上述步骤。
4. 重复执行步骤1~3，直到没有任何元素需要交换位置。
冒泡排序的关键在于每一轮的比较和交换。
在第一轮中，最大的元素会被交换到数组的最后一个位置；在第二轮中，次大的元素会被交换到倒数第二个位置；以此类推，直到所有的元素都排好序。
虽然冒泡排序的思想简单，但它的时间复杂度较高。
在最坏的情况下，即待排序数组是逆序的情况下，冒泡排序需要执行n-1轮比较和交换，其中n是数组的长度。
因此，冒泡排序的时间复杂度为O(n^2)。
尽管冒泡排序的时间复杂度较高，但它有一些优点。
首先，冒泡排序是一种稳定的排序算法，即相等元素的相对顺序不会改变。
其次，冒泡排序是一种原地排序算法，不需要额外的辅助空间。
再次，对于小规模的数组来说，冒泡排序是一种简单有效的排序方法。
虽然冒泡排序的性能相对较差，但在某些特殊的情况下，它可能是最优的选择。
例如，如果一个数组已经基本有序，只有很少的元素需要交换位置，那么冒泡排序的性能会比较好。
冒泡排序的实现可以使用递归算法。
递归是一种通过函数调用自身的方式来解决问题的方法。
在冒泡排序中，我们可以将每一轮的比较和交换封装成一个递归函数。
具体实现上，我们可以将冒泡排序的比较和交换部分放在递归函数中，而将每一轮的遍历部分放在外部的循环中。
在每一轮的遍历中，我们可以调用递归函数来处理前n-1个元素，然后再处理剩下的最后一个元素。
递归实现的冒泡排序代码如下所示：```pythondef bubble_sort_recursive(arr, n):if n == 1:returnfor i in range(n-1):if arr[i] > arr[i+1]:arr[i], arr[i+1] = arr[i+1], arr[i]bubble_sort_recursive(arr, n-1)arr = [64, 34, 25, 12, 22, 11, 90]n = len(arr)bubble_sort_recursive(arr, n)print("排序后的数组：")for i in range(len(arr)):print(arr[i], end=" ")```通过递归实现的冒泡排序和迭代实现的冒泡排序在思想上是一样的，只是实现的方式不同。
递归方法的快速排序
递归方法的快速排序快速排序是一种常用的排序算法，它通过递归的方式将数组分成两个子数组，然后对这两个子数组分别进行排序，最终实现整个数组的有序排列。
快速排序的核心思想是通过一个基准值，将数组分成比基准值小和比基准值大的两部分，然后递归地对这两部分进行排序。
快速排序的具体步骤如下：1. 选择一个基准值：从数组中选择一个元素作为基准值，一般选择数组的第一个元素或者随机选择。
2. 划分操作：将数组中比基准值小的元素放在基准值的左边，比基准值大的元素放在基准值的右边。
可以使用两个指针分别从数组的两端开始遍历，当两个指针相遇时，交换相遇位置的元素和基准值。
3. 递归操作：对基准值左边和右边的子数组分别进行快速排序。
递归的终止条件是子数组的长度为1或0，此时子数组已经是有序的。
4. 合并操作：将左边的子数组、基准值和右边的子数组合并成一个有序的数组。
下面我们通过一个具体的例子来说明快速排序的过程：假设有一个无序数组arr = [5, 8, 2, 9, 3, 7]，我们以第一个元素5作为基准值。
我们从数组的两端开始遍历，找到一个比基准值小的元素和一个比基准值大的元素，然后交换它们的位置。
在这个例子中，我们找到2和7，将它们交换位置，数组变为[2, 8, 5, 9, 3, 7]。
然后，我们继续遍历，找到3和5，将它们交换位置，数组变为[2, 3, 5, 9, 8, 7]。
接下来，我们将数组分为左右两个子数组：[2, 3, 5]和[9, 8, 7]，分别对它们进行递归调用快速排序。
对于左边的子数组[2, 3, 5]，我们以2为基准值，进行划分操作，得到[2, 3, 5]。
因为子数组的长度为3，已经是有序的，所以递归结束。
对于右边的子数组[9, 8, 7]，我们以9为基准值，进行划分操作，得到[7, 8, 9]。
同样地，子数组已经有序，递归结束。
将左边的子数组[2, 3, 5]、基准值5和右边的子数组[7, 8, 9]合并起来，得到有序数组[2, 3, 5, 7, 8, 9]。
递归算法及经典例题详解
递归算法及经典例题详解大部分人在学习编程时接触的第一个算法应该就是递归了，递归的思想其实很好理解，就是将一个问题拆分为若干个与本身相似的子问题，通过不断调用自身来求解。
但很多新手在实际操作中却很难正确使用到递归，有时面对问题还会有种无从下手的感觉，在此，我总结了一些解决递归问题的方法和思路，希望对你能有所帮助。
1.什么是递归递归简单来说就是在运行过程中不断调用自己，直到碰到终止条件，返回结果的过程。
递归可以看作两个过程，分别是递和归。
递就是原问题把要计算的结果传给子问题；归则是子问题求出结果后，把结果层层返回原问题的过程。
下面设一个需要经过三次递归的问题，为大家详细看一下递归的过程：当然，现实中我们遇到递归问题是不会按照图中一样一步一步想下来，主要还是要掌握递归的思想，找到每个问题中的规律。
2.什么时候使用递归递归算法无外乎就是以下三点：1.大问题可以拆分为若干小问题2.原问题与子问题除数据规模不同，求解思路完全相同3.存在递归终止条件而在实际面对递归问题时，我们还需要考虑第四点：当不满足终止条件时，要如何缩小函数值并让其进入下一层循环中3.递归的实际运用（阶层计算）了解了大概的思路，现在就要开始实战了。
下面我们来看一道经典例题：求N的阶层。
首先按照思路分析是否可以使用递归算法：1.N！可以拆分为（N-1）！*N2.（N-1）！与N！只有数字规模不同，求解思路相同3.当N=1时，结果为1，递归终止满足条件，可以递归：public static int Factorial(int num){if(num==1){return num;}return num*Factorial(num-1);}而最后的return，便是第四步，缩小参数num的值，让递归进入下一层。
一般来说，第四步往往是最难的，需要弄清该如何缩小范围，如何操作返回的数值，这一步只能通过不断地练习提高了（当然如果你知道问题的数学规律也是可以试出来的）。
递归算法
4563697
4564531 4565926
正中间 的元素
4566088
4572874
17
4120243
4276013
4328968 4397700
4462718
请问： 4565926是否在 此列表当中？ 4565925？
4466240 4475579
4478964
4480332 4494763
4499043
相应的参数来完成，这就是函数或子程序，使用时只需对其名字进行
简单调用就能来完成特定功能。
例如我们把上面的讲故事的过程包装成一个函数，就会得到：
void Story() { puts("从前有座山，山里有座庙，庙里有个老和尚，老和尚在讲故 事，它讲的故事是："); getchar();//按任意键听下一个故事的内容 Story(); //老和尚讲的故事，实际上就是上面那个故事 }
4563697
4564531 4565926
4566088
4572874
16
4120243
4276013
4328968 4397700
4462718
请问： 4565926是否在 此列表当中？
4466240 4475579
4478964
4480332 4494763
4499043
4508710 4549243
(1)对原问题f(s)进行分析,假设出合理的“较小 问题” f(s')( 与数学归纳法中假设 n=k-1时等式 成立相似)； (2)假设f(s')是可解的,在此基础上确定f(s)的解, 即给出 f(s) 与 f(s') 之间的关系 ( 与数学归纳法中 求证n=k时等式成立的过程相似)； (3)确定一个特定情况(如f(1)或f(0))的解,由此 作为递归边界(与数学归纳法中求证n=1时等式 成立相似)。
递归算法
前言说白了递归就象我们讲的那个故事：山上有座庙，庙里有个老和尚，老和尚在讲故事，它讲的故事是：山上有座庙，庙里有个老和尚，老和尚在讲故事，它讲的故事是：……也就是直接或间接地调用了其自身。
就象上面的故事那样，故事中包含了故事本身。
因为对自身进行调用，所以需对程序段进行包装，也就出现了函数。
函数的利用是对数学上函数定义的推广，函数的正确运用有利于简化程序，也能使某些问题得到迅速实现。
对于代码中功能性较强的、重复执行的或经常要用到的部分，将其功能加以集成，通过一个名称和相应的参数来完成，这就是函数或子程序，使用时只需对其名字进行简单调用就能来完成特定功能。
例如我们把上面的讲故事的过程包装成一个函数，就会得到：void Story(){puts("从前有座山，山里有座庙，庙里有个老和尚，老和尚在讲故事，它讲的故事是：");getchar();//按任意键听下一个故事的内容Story(); //老和尚讲的故事，实际上就是上面那个故事}函数的功能是输出这个故事的内容，等用户按任意键后，重复的输出这段内容。
我们发现由于每个故事都是相同的，所以出现导致死循环的迂回逻辑，故事将不停的讲下去。
出现死循环的程序是一个不健全的程序，我们希望程序在满足某种条件以后能够停下来，正如我们听了几遍相同的故事后会大叫：“够了！”。
于是我们可以得到下面的程序：#include<stdio.h>const int MAX = 3;void Story(int n);//讲故事int main(void){Story(0);getchar();return 0;}void Story(int n){if (n < MAX){puts("从前有座山，山里有座庙，庙里有个老和尚，老和尚对小和尚说了一个故事：");getchar();Story(n+1);}else{printf("都讲%d遍了！你烦不烦哪？\n", n);return ;}}上面的Story函数设计了一个参数n，用来表示函数被重复的次数，当重复次数达到人们忍受的极限（MAX次）时，便停下来。
递归算法
return knap(m,n-1); }
3.递归算法设计
递归算法
算法设计和分析
递归算法
Hanoi塔问题
汉诺塔（Tower of Hanoi）游戏据说来源于布拉玛神庙。游戏的 装置如图所示（图上以3个金片例），底座上有三根金的针，第 一根针上放着从大到小64个金片。游戏的目标是把所有金片从 第一根针移到第三根针上，第二根针作为中间过渡。每次只能
建立标号：分别在过程的第一条可执行语句处、每个递归调
用处建立标号，依次为：L0,L1,L2,……，做为入口地址和返 回地址
消去递归调用：局部变量、形参、返回地址入栈,形式参数赋 值，goto语句到L0
修改函数的返回部分：
• 用户栈为空，返回 • 返回值保存到全局变量中，同时将引用参数赋给栈顶的相应变量
{
CStack<int> stack;
int retvalue,retaddr;
int res ;
L0:
if( a < b )
{
res = GCD(b,a);
L1:
;
}
else if( b == 0 )
{
res = a;
}
else
{
res = GCD(b,a%b);
L2:
;
}
return res; }
}
修改标号L1处的递归调用
算法设计和分析
递归算法
else {
//res = GCD(b,a%b); //保护现场
stack.Push(a); stack.Push(b); stack.Push(res); stack.Push(2); //返回地址 stack.Push(b); stack.Push(a%b); //设置函数的调用参数 goto L0; L2: res = retvalue; //返回值放在全局变量里 }
递归算法的组成
递归算法的组成
递归算法是一种直接或间接调用自身函数或者方法的算法。
在计算机编程中，递归算法通常包含以下两个部分：
1. 递归基础：递归基础是递归算法的终止条件，当满足这个条件时，递归调用将停止并返回结果。
在递归基础中，通常包含一个直接的解决方案，用于处理最简单或最小规模的问题。
2. 递归步骤：递归步骤是递归算法的核心部分，它定义了如何将问题分解为较小的子问题，并通过递归调用自身来解决这些子问题。
在每次递归调用中，都会传入不同的参数或更新后的状态，以便逐步解决更大规模的问题。
递归算法的一个关键特性是它会不断地调用自身，直到达到递归基础。
在这个过程中，每一次递归调用都会创建一个新的栈帧，用于保存当前的状态和参数。
当递归终止并返回结果时，栈帧将依次被弹出，直到回到最初的调用位置。
使用递归算法解决问题的优势在于它可以简洁地表达问题的解决方案，并且在某些情况下可以提供更高效的实现。
然而，需要注意的是，递归算法可能会导致栈溢出的问题，尤其是在处理大规模问题时。
因此，在实际应用中需要考虑递归的深度和边界条件的处理。
总的来说，递归算法由递归基础和递归步骤组成，通过不断地将问题分解为子问题并调用自身来解决。
它具有简洁和高效的特点，但需要注意避免栈溢出等问题。
c语言递归算法
c语言递归算法C语言递归算法递归算法是一种基于函数调用的编程方法，即一个函数在执行过程中调用自身，以此实现循环的效果。
C语言中递归函数的应用范围很广，可以帮助我们简化代码结构，提高代码复用率和可读性。
在接下来的文章中，将会详细介绍C语言中递归算法的原理和应用。
1.递归算法的基本原理递归算法的原理非常简单，即一个函数在执行过程中，调用自身直到达到某个结束条件。
换句话说，递归算法就是把一个大问题不断地分成小问题，直到小问题可以轻松解决的时候，再逐层返回最终结果。
2.递归算法的应用2.1.阶乘问题递归算法最经典的应用场景之一就是求阶乘。
阶乘的定义是从1乘到给定的数字n，所以我们可以使用递归函数来求解阶乘问题。
即，如果n等于1，则阶乘就是1；否则阶乘为n乘以n-1的阶乘。
代码如下：```cint factorial(int n){if (n == 1)return 1;elsereturn n * factorial(n-1);}```2.2.斐波那契数列斐波那契数列是另一个非常经典的递归算法实现问题。
斐波那契数列的定义是，前两个数都是1，之后的每一个数都是前两个数的和。
以下是斐波那契数列的递归函数的实现：```cint fibonacci(int n){if (n <= 1)return n;elsereturn fibonacci(n-1) + fibonacci(n-2);}```2.3.越界问题递归函数存在一个重要的问题就是越界问题。
如果递归函数的调用层数过多，会容易就会导致栈内存溢出，从而导致程序崩溃。
为了防止这种情况的发生，我们可以使用迭代方法来提高程序的效率和稳定性。
```cint fibonacci(int n){int result[100];result[0] = 1;result[1] = 1;for(int i=2; i<=n; i++)result[i] = result[i-1] + result[i-2];return result[n-1];}```3.总结本文详细介绍了C语言中递归算法的实现原理和应用场景，从阶乘问题到斐波那契数列，每一个问题都展示了递归算法的优点和缺点，以及如何提高程序的效率和稳定性。
递归算法详解
递归算法详解递归详解通过运⾏时堆栈来⽀持递归的调⽤，在我们刚接触递归的时候，国内很多教材都采⽤求阶乘和菲波那契数列来描述该思想，就如同深受⼤家敬爱的国产的C语⾔程序设计，⽼谭也⽤了阶乘来描述递归，以⾄于很多新⼿⼀看见阶乘就理所当然的认为是递归，坑了不少⼈，说实在的，描述这个思想还是可以，但是利⽤递归求阶乘可是没有⼀点好处，递归解决菲波那契数列效率更是低得惊⼈，这点是显⽽易见的！废话不多说，接下来我们进⼊正题！（不过说实话，我很讨厌接下来这些太理论的东西，说到底就是那么个意思，⼤家懂就好了，也可以当看看故事！我主要说的就是各种各样递归的实例）1：递归算法的思想递归算法是把问题转化为规模缩⼩了的同类问题的⼦问题。
然后函数（或过程）来表⽰问题的解。
在C语⾔中的运⾏堆栈为他的存在提供了很好的⽀持，过程⼀般是通过函数或⼦过程来实现。
递归算法：在函数或⼦过程的内部，直接或者间接地调⽤⾃⼰的算法。
2：递归算法的特点：递归算法是⼀种直接或者间接地调⽤⾃⾝算法的过程。
在计算机编写程序中，递归算法对解决⼀⼤类问题是⼗分有效的，它往往使算法的描述简洁⽽且易于理解。
递归算法解决问题的特点：(1) 递归就是在过程或函数⾥调⽤⾃⾝。
(2) 在使⽤递归策略时，必须有⼀个明确的递归结束条件，称为递归出⼝。
(3) 递归算法解题通常显得很简洁，但递归算法解题的运⾏效率较低。
所以⼀般不提倡⽤递归算法设计程序。
(4) 在的过程当中系统为每⼀层的返回点、局部量等开辟了栈来存储。
递归次数过多容易造成等。
所以⼀般不提倡⽤递归算法设计程序。
3：递归算法的要求递归算法所体现的“重复”⼀般有三个要求：⼀是每次调⽤在规模上都有所缩⼩(通常是减半)；⼆是相邻两次重复之间有紧密的联系，前⼀次要为后⼀次做准备(通常前⼀次的输出就作为后⼀次的输⼊)；三是在问题的规模极⼩时必须⽤直接给出解答⽽不再进⾏，因⽽每次递归调⽤都是有条件的(以规模未达到直接解答的⼤⼩为条件)，⽆条件递归调⽤将会成为死循环⽽不能正常结束。
递归及递归算法图解
递归问题的提出
第一步：将问题简化。 – 假设A杆上只有2个圆盘，即汉诺塔有2层，n＝2。
A
B
C
递归问题的提出
A
B
C
对于一个有 n（n>1）个圆盘的汉诺塔，将n个圆盘分 为两部分：上面的 n-1 个圆盘和最下面的n号圆盘。将 “上面的n-1个圆盘”看成一个整体。
– 将 n-1个盘子从一根木桩移到另一根木桩上
1
当n 1时
n ! n (n 1)! 当n 1时
long int Fact(int n)
{ long int x;
if (n > 1)
{ x = Fact(n-1);
/*递归调用*/
return n*x; }
else return 1;
/*递归基础*/
}
Fact(n) 开始 传进的参数n N n>1
两种不同的递归函数--递归与迭代
21
(2)递归和迭代有什么差别?
递归和迭代(递推)
迭代(递推)：可以自递归基础开始，由前向后依次计算或直
接计算；
递归：可以自递归基础开始，由前向后依次计算或直接计算；
但有些，只能由后向前代入，直到递归基础，寻找一条路径， 然后再由前向后计算。
递归包含了递推(迭代)，但递推(迭代)不能覆盖递归。
递归的概念 (5)小结
战德臣 教授
组合 抽象
构造 递归
用递归 定义
用递归 构造
递归计 算/执行
递归 基础
递归 步骤
两种不同的递归函数
递归
迭代
两种不同的递归函数--递归与迭代
20
(1)两种不同的递归函数?
递归和递推：比较下面两个示例
递归算法
问题分析：我们根据给出的样例可知：每次输出的 结果都是由前一次的结果变化而来的，也就是问题 每推进一步其结果仍维持与原问题的关系，可见采 用递归算法比较合适。其算法的大致过程如下： 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
问题分析：对于这个问题，首先，我们得具备对一 颗二叉树能熟练并且正确写出它的前序、中序、后 序序列的能力，才能编写程序解决问题。 我们根据题中给出的中序及后序序列，可以找出该 树根结点及左右子树。同样对于左右子树，再根据 它们各自的中序及后序序列，又能找出它们的根结 点及它们的左右子树。由此可见，该问题能够被递 归描述。当最后的序列为空时，递归无法再进行下 去，就是递归结束的边界条件。
用递归方法求解全排列
用递归方法求解全排列全排列是指给定一组数，通过不同的排列顺序来得到所有的可能排列。
如果数的个数是n，则全排列的个数是n!（n的阶乘）。
递归方法是一个很好的解决全排列问题的方式。
下面就来介绍一下用递归方法求解全排列的过程。
1. 基本思路求解全排列的思路是从第一个数开始固定，然后对剩余的数进行全排列，这个过程是递归进行的。
递归终止的条件是当只有一个数时，直接输出这个数就是全排列的一个结果。
下面是一个比较标准的求解全排列的递归函数：```void permutation(char* pStr, char* pBegin){if (*pBegin == '\0')printf("%s\n", pStr);else{for (char* pCh = pBegin; *pCh != '\0'; ++pCh){swap(pBegin, pCh);permutation(pStr, pBegin + 1);swap(pBegin, pCh);}}}```2. 函数解析（1）函数参数说明函数有两个参数：char* pStr：表示要进行全排列的字符串，这个字符串会在递归过程中进行排列，最终生成全排列结果。
char* pBegin：表示当前正在固定的字符位置，也就是说，在递归处理中已经固定了前面的字符，pBegin指向下一个要固定的字符位置。
（2）递归终止条件如果pBegin指向了字符串的结尾，也就是说已经固定了整个字符串中的所有字符，那么就输出此时的全排列。
if (*pBegin == '\0')printf("%s\n", pStr);（3）递归循环体在循环体内部，通过一个for循环枚举下一次要固定的字符位置。
在固定字符之前，使用swap函数交换pBegin和pCh指针变量的内容，这一步的目的是交换要固定的字符和下一个将要固定的字符，以此来生成不同的全排列结果。
必备算法：递归！无论你是前端开发，还是后端开发，都需要掌握它！
必备算法：递归！⽆论你是前端开发，还是后端开发，都需要掌握它！递归是⼀种⾮常重要的算法思想，⽆论你是前端开发，还是后端开发，都需要掌握它。
在⽇常⼯作中，统计⽂件夹⼤⼩，解析xml⽂件等等，都需要⽤到递归算法。
它太基础太重要了，这也是为什么⾯试的时候，⾯试官经常让我们⼿写递归算法。
本⽂呢，将跟⼤家⼀起深⼊挖掘⼀下递归算法~什么是递归？递归，在计算机科学中是指⼀种通过重复将问题分解为同类的⼦问题⽽解决问题的⽅法。
简单来说，递归表现为函数调⽤函数本⾝。
在知乎看到⼀个⽐喻递归的例⼦，个⼈觉得⾮常形象，⼤家看⼀下：❝递归最恰当的⽐喻，就是查词典。
我们使⽤的词典，本⾝就是递归，为了解释⼀个词，需要使⽤更多的词。
当你查⼀个词，发现这个词的解释中某个词仍然不懂，于是你开始查这第⼆个词，可惜，第⼆个词⾥仍然有不懂的词，于是查第三个词，这样查下去，直到有⼀个词的解释是你完全能看懂的，那么递归⾛到了尽头，然后你开始后退，逐个明⽩之前查过的每⼀个词，最终，你明⽩了最开始那个词的意思。
❞来试试⽔，看⼀个递归的代码例⼦吧，如下：递归的特点实际上，递归有两个显著的特征,终⽌条件和⾃⾝调⽤:✿⾃⾝调⽤：原问题可以分解为⼦问题，⼦问题和原问题的求解⽅法是⼀致的，即都是调⽤⾃⾝的同⼀个函数。
✿终⽌条件：递归必须有⼀个终⽌的条件，即不能⽆限循环地调⽤本⾝。
结合以上demo代码例⼦，看下递归的特点：递归与栈的关系其实，递归的过程，可以理解为出⼊栈的过程的，这个⽐喻呢，只是为了⽅便读者朋友更好理解递归哈。
以上代码例⼦计算sum（n=3）的出⼊栈图如下：为了更容易理解⼀些，我们来看⼀下函数sum（n=5）的递归执⾏过程，如下：✿计算sum（5）时，先sum（5）⼊栈，然后原问题sum（5）拆分为⼦问题sum（4），再⼊栈，直到终⽌条件sum（n=1）=1，就开始出栈。
✿ sum（1）出栈后，sum（2）开始出栈，接着sum（3）。
✿最后呢，sum（1）就是后进先出，sum（5）是先进后出，因此递归过程可以理解为栈出⼊过程啦~递归的经典应⽤场景哪些问题我们可以考虑使⽤递归来解决呢？即递归的应⽤场景⼀般有哪些呢？✿阶乘问题✿⼆叉树深度✿汉诺塔问题✿斐波那契数列✿快速排序、归并排序（分治算法体现递归）✿遍历⽂件，解析xml⽂件递归解题思路解决递归问题⼀般就三步曲，分别是：✿第⼀步，定义函数功能✿第⼆步，寻找递归终⽌条件✿第⼆步，递推函数的等价关系式这个递归解题三板斧理解起来有点抽象，我们拿阶乘递归例⼦来喵喵吧~1、定义函数功能定义函数功能，就是说，你这个函数是⼲嘛的，做什么事情，换句话说，你要知道递归原问题是什么呀？⽐如你需要解决阶乘问题，定义的函数功能就是n的阶乘，如下：2、寻找递归终⽌条件递归的⼀个典型特征就是必须有⼀个终⽌的条件，即不能⽆限循环地调⽤本⾝。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
4.5递归算法与递归程序【课标要求】（三）算法与问题解决例举1. 内容标准递归法与问题解决（1）了解使用递归法设计算法的基本过程。
（2）能够根据具体问题的要求，使用递归法设计算法、编写递归函数、编写程序、求解问题。
【教材分析】“算法的程序实现”是《算法与程序设计》选修模块第三单元的内容，本节课是“递归算法的程序实现”，前面学习了用解析法解决问题、穷举法解决问题、在数组中查找数据、对数进行排序以及本节的前一小节知识点“什么是自定义函数”的学习，在学习自定义函数的基础上，学习递归算法的程序实现是自定义函数的具体应用，培养学生“自顶向下”、“逐步求精”的意识起着重要的作用。
『递归算法在算法的学习过程中是一个难点，在PASCAL和C语言等程序语言的学习过程中，往往是将其放在“函数与过程”这一章节中来讲解的。
递归算法的实现也是用函数或是过程的自我调用来实现的。
从这一点上来讲，作者对教材的分析与把握是准确的，思路是清晰的，目标是明确的。
』【学情分析】教学对象是高中二年级学生，前面学习了程序设计的各种结构，在学习程序设计各种结构的应用过程中培养了用计算机编程解决现实中问题的能力，特别是在学习循环语句的过程中，应用了大量的“递推”算法。
前一节课学习了如何自定义函数，在此基础上学习深入学习和体会自定义函数的应用。
以递推算法的逆向思维进行求解问题，在学习过程中体会递归算法的思想过程。
多维度的思考问题和解决问题是提高学生的学习兴趣关键。
『递归算法的本质是递推，而递推的实现正是通过循环语句来完成的。
作者准确把握了学生前面的学习情况，对递归算法的本质与特征也分析的很透彻，可以说作者对教学任务的分析是很成功的，接来就要看，在成功分析的基础上作者是如何通过设计教学来解决教学难点的了。
』【教学目标】知识与技能：理解什么是递归算法，学生会用递归算法的思想分析问题能够应用自定义函数方法实现递归算法的编程过程与方法：学生参与讨论，通过思考、动手操作，体验递归算法的方法情感态度与价值：结合数学中的实例，激发学生的数学建模的意识，培养学生多维度的思考问题和解决问题。
『教学目标设计的合理、准确。
这也是在意料之中的，一般情况下，成功的教学任务分析一定会带来成功的教学目标设计。
』【重点难点】重点：理解什么是递归算法，学生用递归算法的思想分析问题；应用自定义函数方法实现递归算法的编程难点：应用自定义函数方法实现递归算法的编程『大部分教师在确立教学重、难点时不会给出确立的依据，可能这些依据早就在教师的脑中明确了，也有可能是一笔糊涂账，只不过是教参上是这样写的就照搬过来而已。
如果在写教学重、难点的同时能再给出确立重、难点的依据会令教案更具借鉴意义。
本案例的作者虽然没有写依据，但由于前面成功的教学任务分析，也就自然确立了教学重、难点。
这也是很好的。
』【教学过程】进程教师活动学生活动设计意图创设情境课堂导入：今天很高兴，特此我给大家准备了一份礼品（精美包装猴与兔艺术品），你们想知道里面有什么礼物吗？学生：想……师：好！我们班有一位同学知道里面有什么礼物！(在上课之前事先告诉其中的一个同学)但是他不能就这样告诉大家，有一个规则可以让我们知道里面装的是什么……规则是：1.从第一排的第一个同学开始。
2.每位同学只问他相邻的同学，每位同学最多只能被问一次，而且一个同学不能再问第二人，当任何一个同学知道了答案,要求立即告诉曾经问过他的那个同学(不能告诉其他同学)以此类推。
3.一直到得出答案为结束。
以游戏规则开展，我想让第一位同学告诉大家，精装的礼物是什么？师生共同活动“找答案”使用情境教学法在此活动过程中能让学生初步从活动中体验“问题的发与收”从而走进了递归的思维模式，为进一步学习递归算法埋下伏笔『这样的课堂导入方式是一种令人兴奋的方式。
令人兴奋的原因有两个：其一，以“活动”的方式来引导学生探讨一个问题是学生们非常喜欢的方式，学生喜欢，就会产生强烈的兴趣，但还不是学习动机。
但因为“活动”与“所要探讨的问题”十分的贴切，是问题的典型代表，学生强烈的兴趣就会自然而然地转化为学习动机。
这种学习动机的激发方式比我们直白地告诉学生某某知识点有多么多么重要，我们一定要好好学要来的自然有效的多，是我们需要努力借鉴并执之以恒的。
其二，由于递归算法的学习比较难，直接进行教学对学生的思维能力要求较高，往往达不到预想的效果。
但用新颖有趣的活动来引导学生在积极的参与过程中自然地思考老师希望他们思考的问题，并体验问题解决的过程，就会获得较好的学习效果和较高的学习效率。
以“活动”的方式引导教学的形式虽然很好，但也是比较难设计的。
难就难在“活动”的设计一定要能充分恰当地展示要学习的内容和要探讨的问题。
如果只是为了活动而活动，既浪费了宝贵的课堂教学时间，也降低了课堂教学效率，是非常不可取的。
因此，成功的活动设计对教师的要求很高，需要老师有扎实的学科知识功底和丰富的社会阅历。
』启发主体师：前面我们学习了自定义函数，知道函数是为了实现某种功能而编写的一段相对独立的程序，并且可以多次的调用。
算法描述：function what(student)如果我知道答案，那么我就告诉你否则，我要问下一位同学再告诉你end function讨论活动过程，总结游戏规则，了解活动规律，并将活动过程进行算法描述分析问题确定方案,培养学生思维程序化，为下面新学习递归算法做好移植准备『这一部分的设计较之于前一段，立刻显得平淡，缺乏“热闹”。
然而，这看似平淡的教学过程却是画龙点睛之笔。
如果没有这一段教学的及时总结，对前一“活动”过程思维上的提升，那前面的活动就只能流于形式、止步于“热闹”了。
因此，我们在用“活动”的方式引入教学之后，要注意及时总结活动并提升到所要探讨的问题，这样才算完成了教学。
活动的开展，目的也是为了让学生能较容易地掌握新知进行铺垫并对问题进行深入思考。
』学习新知展示题：小猴吃桃:有一天小猴子摘若干个桃子,当即吃了一半还觉得不过瘾,又多吃了一个。
第二天接着吃剩下桃子中的一半，仍觉得不过瘾又多吃了一个，以后小猴子都是吃尚存桃子一半多一个。
到第10天早上小猴子再去吃桃子的时候，看到只剩下一个桃子。
问小猴子第一天共摘下了多少个桃子?1.鼓励学生进行讨论，共同寻找答案或解决方法2.师生共同分析题：以4位同学排成了行，（设从行的后面开始的第一位同学知道第10的桃子数（1个），倒数第二位同学知道第9天的桃子数是……）从教师提问排在前面第一位（第7天）的同学，你知道，你今天的桃子数有多少？讨论、比较、分析、归纳实例教学，选择“小猴吃桃”这一题的目的是为了简化教材“裴波那契”数列的多函数调用，回避问题分析的复杂性较大的特点，从而使得重点难点得以轻松的突破。
目的是讨论出，只有倒数第一位同学知道，其他有同学都不知道，但是他只要知道他后一位同学的桃子数就可以求出本人所具有的桃子数，（后同学的桃子数+1）*2就是本人的桃子数。
『看来作者真是一个善于通过“活动”的方式来完成教学的“高手”，在降低了分析问题的难度以后，再一次用活动的方式来引导学生来分析问题，这是一种真正意义上的循循善诱，比教师不厌其烦地教给学生十遍公式要来的高效的多。
』建立数学模型：假设第n,n<10天的桃子数为tao(n)那么tao=10 n=1tao(n)=(tao(n+1)+1)*2 n<10推导数学建模我们能不能这样设一个函数：算法描述：function你有多少桃子？（第几天）如果我第10天，那么我就有一个桃子。
否则，我的桃子数=（前一天的桃子数+1）*2 end function 学生进行算法描述培养学生养成良好的编程习惯『还是的，在“活动”过后要及时的总结与提升。
先在分析的基础上建立数学模型，再用伪代码来描述，严格按计算机解决问题的基本过程来展开课堂教学，不断培养与强化学生良好的编程习惯。
』学生编程实现：Function tao(ByVal days As Integer) As Integer If days = 10 Thentao = 1Elsetao = (tao(days + 1) + 1) * 2End IfEnd Function 分析算法的实现过程学生编程实现示图协助学生算法实现过程的始末思维，培养学生的编程和调试程序能力，让学生获得成功的体检『再用示图的方式来帮助学生进行思维，降低学生思维的难度（并没有降低思维的质量），从而提高教学效率。
再让学生动手编写代码，实践计算机解决问题基本过程的最后一步。
至此，用递归算法解决“猴子摘桃”问题的全过程完成了。
』自主构建我们再来看第二题：（学生阅读教材P68，让学生阅读教材的“裴波那契”，培养学生的自学能力、和知识迁移建构自我的知识体系）裴波那契（Fibonacci leonardo，约1170-1250）是意大利著名数学家．在他的著作《算盘书》中许多有趣的问题，最富成功的问题是著名的“兔子繁殖问题”：如果每对兔子每月繁殖一对子兔，而子兔在出生后第二个月就有生殖能力，试问第一月有一对小兔子第十二月时有多少对兔子？1、1、2、3、5、8、13、21……假设第n个月的兔子数目为f(n)，那么f(n)=F(n-1)+f(n-2) 当n≥3，f(1)=f(2)=1讨论得出算法描述Function有多少对兔子（第几月）如果是第一月或第二月，那么就有一对兔子。
否则，（本月）兔子数=（本月-1）月的兔子数+（本月-2）月的兔子数end FunctionFunction tu(ByVal month As Integer) As IntegerIf month = 1 Or month = 2 Thentu = 1Elsetu = tu(month - 1) + tu(month - 2)End IfEnd Function阅读思考、分析、讨论，编程实现。
尊重学生的个体发展，让学生进行自主探究学习，使用学主动、积极的学习新知识，培养他们的自学能力。
培养学生分析问题、解决问题能力，煅练学生“数学建模”建构主义的学习观认为：学习不是被动接收信息，而是主动地建构意义，以自己原有的知识经验为基础对外部信息进行主动地选择、加工和处理，人而获得自己的意义过程。
『在学生经历了上一问题解决的完整过程之后，再抛出较难的问题，并让学生自主完成。
一方面，学生有了前面的基础，自主完成稍难一点问题的解决是完全可能的，另一方面，通过问题的“变式”，强化了新知，也训练了学生独立思考，分析解决问题的能力。
』深化知识阅读教材的循环结构实现，比较讨论两种算法的区别和特点学生讨论培养学生分析问题、归纳、梳理知识的能力，通过两种算法的对比，让学生深入体会递归算法的魅力。
加深对本节课所学知识的理解。