递归与回溯算法
matlab回溯算法代码
matlab回溯算法代码Matlab回溯算法代码回溯算法是一种常用的解决问题的方法，可以用于求解诸如组合问题、排列问题、子集问题等。
在Matlab中，我们可以使用回溯算法来解决各种实际问题，下面是一个基于Matlab的回溯算法代码示例。
我们定义一个函数backtracking，该函数接受参数n和k，n表示待解问题的规模，k表示每个解的长度。
在函数内部，我们定义一个数组solution来存储每个解，一个变量count用于记录当前解的长度。
接下来，我们使用递归的方式来实现回溯算法。
在递归函数backtrack中，我们首先判断当前解的长度是否达到了k，如果达到了，则将该解存入结果数组result中，并返回。
如果当前解的长度还没有达到k，我们就从1到n的范围内选择一个数加入到当前解中，并调用backtrack函数进行下一步的递归。
递归结束后，我们将当前选择的数从解中移除，然后继续选择下一个数进行递归。
我们在主函数中调用backtracking函数，并将得到的结果进行输出。
下面是完整的Matlab回溯算法代码示例：```function result = backtracking(n, k)solution = [];count = 0;result = [];backtrack(1);function backtrack(start)if count == kresult = [result; solution]; return;endfor i = start:nsolution = [solution, i];count = count + 1;backtrack(i + 1);solution = solution(1:end-1); count = count - 1;endendendresult = backtracking(4, 2);disp(result);```上述代码中，我们以n=4，k=2为例进行了一次回溯算法的求解。
回溯与递归
回溯与递归
回溯和递归都是算法中常用的概念，通常用于解决一些复杂的问题。
回溯（Backtracking）是一种试探性的算法思想，它可以在解
决问题的过程中进行“回溯”，即通过不断的尝试，找到一条解决问题的路径。
回溯算法通常应用于求解每一个可能的解，并对每一个解进行检查，最终找到一个满足条件的解。
回溯算法通常使用递归的方式实现，每次尝试一个可能的解，如果该解行不通，就回溯到前一步，再尝试另一个可能的解，直到找到一个满足条件的解。
递归（Recursion）是一种算法思想，它将问题的求解转化为
对自身的调用，通常包含一个或多个基准情况和一个或多个递归情况。
递归算法通常需要将问题分解成若干个子问题，然后递归求解每一个子问题的解，最终将子问题的解合并成原问题的解。
递归算法通常用于处理数据结构中的树、图、链表等结构，并可以方便地实现回溯算法。
总的来说，回溯算法是通过尝试所有可能的解来找到一个满足条件的解，而递归算法是通过逐层递归求解子问题的解，最终得到原问题的解。
在实际应用中，回溯算法和递归算法常常相互结合，并且可以通过剪枝等方式进行优化，提高算法的效率。
回溯法的几种算法框架
回溯法的几种算法框架回溯法是一种经典的求解问题的算法框架，通常用于解决组合优化、搜索和排列问题。
下面将介绍回溯法的几种常见算法框架。
1. 全排列问题：全排列问题是指对给定的一组数字或字符，求出所有可能的排列方式。
回溯法可以通过递归的方式实现。
首先选择一个初始位置，然后从剩余的数字中选择下一个位置，依次类推，直到所有位置都被填满。
当所有位置都填满时，得到一个排列。
随后继续回溯，在上一次选择的位置后面选择下一个数字，直到得到所有的排列。
2. 子集问题：子集问题是指对给定的一组数字或字符，求出所有可能的子集。
回溯法可以通过递归的方式实现。
从给定的集合中选择一个元素，可以选择将其添加到当前正在构建的子集中，也可以选择跳过。
递归地遍历所有可能的选择路径，直到得到所有的子集。
3. 组合问题：组合问题是指在给定的一组数字或字符中，取出若干个元素进行组合，求解出所有不重复的组合方式。
回溯法可以通过递归的方式实现。
从给定的集合中选择一个元素，将其添加到当前正在构建的组合中，然后以当前选择元素的下一个位置为起点，递归地构建后续的组合。
如果当前组合已经满足条件或者已经遍历完所有可能的位置，则回溯到上一次选择的位置，继续尝试其他可能的选择。
4. 搜索问题：搜索问题是指在给定的搜索空间中，找到满足特定条件的解。
回溯法可以通过递归的方式实现。
从初始状态开始，选择一个操作或移动方式，然后递归地探索所有可能的状态转移路径。
每次探索时，进行剪枝操作，排除一些不符合条件的状态。
当找到满足条件的解或搜索空间遍历完时，回溯到上一次选择的位置，继续探索其他可能的路径。
总结：回溯法是一种求解问题的经典算法框架，适用于组合优化、搜索和排列问题。
通过选择和回溯的方式，可以遍历所有可能的解空间，并找到满足特定条件的解。
在实际应用中，可以根据具体问题的特点，选择合适的算法框架和相应的优化策略，以提高算法的效率和准确性。
计算机算法设计五大常用算法的分析及实例
计算机算法设计五⼤常⽤算法的分析及实例摘要算法（Algorithm）是指解题⽅案的准确⽽完整的描述，是⼀系列解决问题的清晰指令，算法代表着⽤系统的⽅法描述解决问题的策略机制。
也就是说，能够对⼀定规范的输⼊，在有限时间内获得所要求的输出。
如果⼀个算法有缺陷，或不适合于某个问题，执⾏这个算法将不会解决这个问题。
不同的算法可能⽤不同的时间、空间或效率来完成同样的任务。
其中最常见的五中基本算法是递归与分治法、动态规划、贪⼼算法、回溯法、分⽀限界法。
本⽂通过这种算法的分析以及实例的讲解，让读者对算法有更深刻的认识，同时对这五种算法有更清楚认识关键词：算法，递归与分治法、动态规划、贪⼼算法、回溯法、分⽀限界法AbstractAlgorithm is the description to the problem solving scheme ,a set of clear instructions to solve the problem and represents the describe the strategy to solve the problem using the method of system mechanism . That is to say, given some confirm import，the Algorithm will find result In a limited time。
If an algorithm is defective or is not suitable for a certain job, it is invalid to execute it. Different algorithms have different need of time or space, and it's efficiency are different.There are most common algorithms: the recursive and divide and conquer、dynamic programming method、greedy algorithm、backtracking、branch and bound method.According to analyze the five algorithms and explain examples, make readers know more about algorithm , and understand the five algorithms more deeply.Keywords: Algorithm, the recursive and divide and conquer, dynamic programming method, greedy algorithm、backtracking, branch and bound method⽬录1. 前⾔ (4)1.1 论⽂背景 (4)2. 算法详解 (5)2.1 算法与程序 (5)2.2 表达算法的抽象机制 (5)2.3 算法复杂性分析 (5)3．五中常⽤算法的详解及实例 (6)3.1 递归与分治策略 (6)3.1.1 递归与分治策略基本思想 (6)3.1.2 实例——棋盘覆盖 (7)3.2 动态规划 (8)3.2.1 动态规划基本思想 (8)3.2.2 动态规划算法的基本步骤 (9)3.2.3 实例——矩阵连乘 (9)3.3 贪⼼算法 (11)3.3.1 贪⼼算法基本思想 (11)3.3.2 贪⼼算法和动态规划的区别 (12)3.3.3 ⽤贪⼼算法解背包问题的基本步骤： (12)3.4 回溯发 (13)3.4.1 回溯法基本思想 (13)3.3.2 回溯发解题基本步骤 (13)3.3.3 实例——0-1背包问题 (14)3.5 分⽀限界法 (15)3.5.1 分⽀限界法思想 (15)3.5.2 实例——装载问题 (16)总结 (18)参考⽂献 (18)1. 前⾔1.1 论⽂背景算法（Algorithm）是指解题⽅案的准确⽽完整的描述，是⼀系列解决问题的清晰指令，算法代表着⽤系统的⽅法描述解决问题的策略机制。
排列组合配对问题算法
排列组合配对问题算法排列组合配对问题，其实就是在已知有一组数据，需要对其进行组合，找到所有可能的组合情况，进而进行配对。
这个问题涉及到了算法和数学的知识，需要进行一定的计算和分析。
在这篇文章中，我将介绍几种常用的排列组合配对算法，并阐述它们的原理及其实现过程。
1. 回溯算法回溯算法是一种递归算法，用于解决包括排列、组合和背包问题等在内的一系列问题。
其核心思想是在搜索进程中遇到了问题，就返回上一级，尝试另一种可能性，直至找到问题的解法。
在排列组合配对问题中，回溯算法可以通过生成子集和排列来求解所有的组合。
生成子集的算法流程：（1）初始化一个数组 arr，表示给定的集合；（2）定义一个函数 dfs(start, subset)，其中 start 表示起始位置，subset 表示当前子集；（3）遍历数组 arr，对于每个数，都有两种可能性：将其加入子集中或不加入子集中。
如果加入，则将该数加入 subset，并递归调用 dfs(start+1, subset)，更新 start 和 subset；如果不加入，则仅递归调用 dfs(start+1, subset)。
生成排列的算法流程：（1）初始化一个数组 arr，表示给定的集合；（2）定义一个函数 dfs(pos)，其中 pos 表示已选择的数的个数；（3）遍历数组 arr，对于每个数，判断其是否已经被选择过。
如果没有，则将该数加入已选择的数中，并递归调用dfs(pos+1)，更新选择的数和 pos；如果已经被选择过，则不进行任何操作。
2. 位运算算法位运算算法与回溯算法类似，也可以用于求解排列和组合问题。
它的优势在于，通过位运算可以直接表示一个集合的子集或排列，而不需要额外的内存空间。
因此，位运算算法可以大大提高运算效率。
生成子集的算法流程：（1）初始化一个集合 set，表示给定的集合；（2）计算出集合 set 的元素个数 n，然后构建一个二进制串，表示从左到右每个元素是否在子集中，其中 0 表示不在，1 表示在。
递归经典题目
递归经典题目
递归是一种常用的算法技术，它可以用来解决许多经典问题。
以下是一些经典的递归问题：
1. 斐波那契数列：这是一个经典的递归问题，其中每个数字是前两个数字的和。
例如，斐波那契数列的前几个数字是 0、1、1、2、3、5、8、13、21 等。
2. 阶乘函数：这是一个计算一个数的阶乘的递归函数。
例如，5 的阶乘是 5 4 3 2 1 = 120。
3. 汉诺塔问题：这是一个经典的递归问题，其中有一些盘子需要从一根柱子移动到另一根柱子，每次只能移动一个盘子，并且不能将一个较大的盘子放在较小的盘子上面。
4. 二分搜索：这是一个在排序数组中查找特定元素的递归算法。
它首先将数组分成两半，然后根据目标值与中间元素的比较结果，选择另一半继续搜索。
5. 回溯算法：这是一种通过递归搜索所有可能解的算法，通常用于解决约束满足问题。
例如，排列组合问题、八皇后问题等。
6. 分治算法：这是一种将问题分解为更小的子问题，然后递归地解决这些子问题的算法。
例如，归并排序和快速排序等。
7. 动态规划：这是一种使用递归和备忘录（或称为记忆化）的方法，用于解决具有重叠子问题和最优子结构的问题。
例如，背包问题和最短路径问题等。
这些经典的递归问题涵盖了不同的应用领域和算法类型，可以通过学习和解决这些问题来提高自己的编程和算法技能。
第5章 回溯法
（1）如果X=(x1, x2, …, xi＋1)是问题的最终解，则输出这个解。 如果问题只希望得到一个解，则结束搜索，否则继续搜索其 他解； （2）如果X=(x1, x2, …, xi＋1)是问题的部分解，则继续构造解 向量的下一个分量； （3）如果X=(x1, x2, …, xi＋1)既不是问题的部分解也不是问题 的最终解，则存在下面两种情况： ① 如果xi+1= ai＋1k不是集合Si＋1的最后一个元素，则令xi+1= ai＋ 1k＋1，即选择Si+1的下一个元素作为解向量X的第i+1个分量； ② 如果xi+1= ai＋1k是集合Si＋1的最后一个元素，就回溯到X=(x1, x2, …, xi)，选择Si的下一个元素作为解向量X的第i个分量，假 设xi= aik，如果aik不是集合Si的最后一个元素，则令xi= aik＋1； 否则，就继续回溯到X=(x1, x2, …, xi－1)； 15
2 3
4
3
4
1
3ห้องสมุดไป่ตู้
1
4
2
4
1
2
1
2
3
3
1
2
1
10 12 15 17 21 23 26 28 31 33 37 39 42 44 47 49 52 54 57 59 62 64 n=4的TSP问题的解空间树
8
解空间树的动态搜索（1）
回溯法从根结点出发，按照深度优先策略遍历 解空间树，搜索满足约束条件的解。 在搜索至树中任一结点时，先判断该结点对应 的部分解是否满足约束条件，或者是否超出目标函 数的界，也就是判断该结点是否包含问题的（最优） 解，如果肯定不包含，则跳过对以该结点为根的子 树的搜索，即所谓剪枝（ Pruning ）；否则，进入 以该结点为根的子树，继续按照深度优先策略搜索。
著名算法matlab编程 贪心算法 背包问题 递归算法 Hanoi塔问题 回溯算法 n皇后问题
10/22
在命令窗口输入：>> [n,s]=hanoi(3,1,2,3) n= 7 s= 1 2 1 3 1 2 1 1 1 3 1 2 2 1 3 2 2 3 1 3 3
1
1 2 3
2 3 3 3 1
2
3
1
2 1 2
1
1 2
2
3
3
1
2 3
1 2 3
11/22
5/22
A
B
C
1
2
n
6/22
问题分析： 把柱C作为目标柱子，设an为n块金片从其中一柱移 到另一柱的搬运次数，则把n块金片从A移到C，可 以先把前n-1片移到B，需搬an-1次；接着把第n片从 A称到C，再从B把剩下的n-1片搬到C，又需搬an-1 次。所以从A到n块金片称到柱C，共需次数为： 2an-1+1次。 显然，当n=1时，a1=1，所以Hanoi塔的移动次数相 当于一个带初值的递归关系：
有 旅 行 者 要 从 n 种 物 品 中 选 取 不 超 过 b公 斤 的 物 品 放 入 背 包 ， 要 求 总 价 值 最 大 。 设 第 i 种 物 品 的 重 量 为 a i， 价 值 为 c i，i 1, 2 , n )。 定 义 向 量 [ x 1 , x 2 , , x n ]， 当 选 第 i ( 种 物 品 往 背 包 放 时 取 x i 1， 否 则 取 x i 0。 于 是 所 有 选 取 的 物 品 的 总 价 值 为 ： c 1 x 1 c 2 x 2 c n x n， 总 的 重 量 为 ： a 1 x 1 a 2 x 2 a n x n。 问 题 可 描 述 为
递归回溯算法
递归回溯算法简介递归回溯算法是一种解决问题的算法思想，它通过不断地尝试所有可能的解决方案，并在每一步中进行回溯，即撤销上一步的选择，直到找到满足条件的解。
这种算法思想通常用于解决组合优化问题，如全排列、子集、背包等。
概念解析•递归：递归是指一个函数调用自身的过程。
在递归回溯算法中，递归函数通常用于尝试解决问题的每一步。
•回溯：回溯是指当无法继续前进时，回退到上一层的过程。
在递归回溯算法中，回溯通常用于撤销上一步的选择，以尝试其他可能的解决方案。
算法框架递归回溯算法的框架通常包括以下几个步骤：1.确定递归函数的输入参数和返回值：通常需要传入当前的状态和已经做出的选择，返回解决方案或最优解。
2.确定递归函数的终止条件：当满足终止条件时，停止继续递归，返回解决方案或最优解。
3.确定每一步的选择范围：根据实际情况，确定可以做出的选择范围。
4.根据选择范围，在每一步中进行递归调用：对每一个选择进行递归调用，尝试解决问题的下一步。
5.在每一步中进行回溯：如果当前选择导致无法继续前进，进行回溯，撤销上一步的选择，尝试其他可能的解决方案。
6.处理结果：根据实际需求，对每一个解决方案进行处理，如输出结果、更新最优解等。
应用场景递归回溯算法在很多问题中都有应用，特别是在组合优化问题中更为常见。
下面列举几个常见的应用场景：1. 全排列全排列是指将一组元素进行排列，列出所有可能的排列情况。
对于一个含有n个元素的集合，全排列的结果共有n!种可能。
算法思路：1.从集合中选择一个元素作为当前位置的元素。
2.使用递归算法求解剩余元素的全排列。
3.当集合中只剩下一个元素时，输出当前排列情况。
4.撤销上一步的选择，尝试其他可能的排列情况。
2. 子集子集是指在一个集合中，取出部分或全部元素形成的集合。
对于一个含有n个元素的集合，子集的结果共有2^n种可能。
算法思路：1.不选择当前元素，进入下一层递归。
2.选择当前元素，进入下一层递归。
采用递归回溯法设计一个算法,求从1~n的n个整数中取出m个元素的排列,要求每个元素
采用递归回溯法设计一个算法，求从1~n的n个整数中取出m个元素的排列，要求每个元素最多只能取一次。
例如，n=3,m=2的输出结果是(1,2),(1,3),(2,1),(2,3), (3,1),(3,2)。
思路一：先用递归法从n nn个数中取出m mm个数（组合问题）。
再通过回溯的排列树模板对m mm个数进行全排列。
输出排列。
C++实现如下：//// main.cpp// algorithm//// Created by LilHoe on 2020/9/21.//#include <iostream>#include <vector>#include <algorithm> //导入swap函数using namespace std;void display(vector<int> chosenNum, int m){ //打印一组排列for (int i = 0; i < m; i++) {cout<<chosenNum[i]<<"\t";}cout<<endl;}/* 排列:对m个不同的数全排列*/void permutation(vector<int> chosenNum, int m, int i){if (i>=m) {display(chosenNum, m);}else{for (int j=i; j<m; j++) {swap(chosenNum[i], chosenNum[j]);permutation(chosenNum, m, i+1);swap(chosenNum[i], chosenNum[j]);}}}/* 组合:取出m个数*/void combination(int n, int m, vector<int> indexVec,vector<int> numbers, int level){int begin,end;if (level==0) //初始化从根节点开始遍历begin=0;elsebegin = indexVec[level-1] + 1;end = n-m+level; //确定每层的尾指针for (int i = begin;i <= end;i++){indexVec[level] = i; //将取到的元素的下标放在indexVec数组中,以递增方式排列if (level == m-1){ //已经取了m个元素vector<int> chosenNum; //存储选出的数字for (int i = 0; i<m; i++) {chosenNum.push_back(numbers[indexVec[i]]);}permutation(chosenNum, m, 0); //取出m个元素,再进行排列}else{combination(n,m,indexVec,numbers,level+1); //继续取一个元素}}}int main(int argc, const char * argv[]) {int m,n;cout<<"求1～n的n个整数中取出m个元素的排列"<<endl;cout<<"输入n:"<<endl;cin>>n;cout<<"输入m（不大于n）"<<endl;cin>>m;if (m>n) {cout<<"输入的m大于n!错误!"<<endl;exit(0);}vector<int> numbers; //将1-n转化成数组for (int i = 1; i <= n; i++) {numbers.push_back(i);}vector<int> indexVec(m); //记录所选取的m个数的下标cout<<"排列结果:"<<endl;combination(n, m, indexVec, numbers, 0);return 0;}运行结果：思路二：整体采用回溯法递归排列树的框架，通过选择一次取数，取完m个数就输出，并取的数一次不取，继续遍历得到全部结果。
java 回溯解法
java 回溯解法摘要：1.回溯算法概述2.Java 回溯算法实现3.Java 回溯算法示例4.总结正文：一、回溯算法概述回溯算法（Backtracking Algorithm）是一种解决问题的算法思想，通过尝试所有可能的解决方案来解决问题，直到找到符合要求的解决方案为止。
回溯算法的基本思想是：从一条路往前走，当发现此路不通时，就回到上一个路口，再选择另一条路往前走。
这种算法在程序设计中应用广泛，特别是在组合优化问题、数独求解等方面。
二、Java 回溯算法实现在Java 语言中，回溯算法可以通过递归或者迭代的方式实现。
下面我们分别介绍这两种实现方式：1.递归实现递归实现的回溯算法比较简单，基本思路是将问题分解成规模较小的相似子问题，然后通过递归调用求解子问题，最后将子问题的解合并成原问题的解。
2.迭代实现迭代实现的回溯算法需要借助一个数据结构来记录已经尝试过的解决方案，以避免重复尝试。
通常使用一个布尔数组来记录已经尝试过的方案。
在迭代过程中，每次尝试一个新方案，如果该方案可行（即满足约束条件），则将其加入可行解集合，并继续尝试其他方案；如果该方案不可行，则回溯到上一个方案，继续尝试其他方案。
三、Java 回溯算法示例下面我们以一个简单的八皇后问题为例，展示如何使用Java 实现回溯算法。
八皇后问题是一个经典的回溯算法应用，问题描述如下：在8×8 的棋盘上放置8 个皇后，使得任何一个皇后都无法攻击到另一个皇后。
即任意两个皇后都不在同一行、同一列和同一对角线上。
四、总结回溯算法是一种解决问题的思路，通过尝试所有可能的解决方案来解决问题。
在Java 语言中，回溯算法可以通过递归或者迭代的方式实现。
回溯算法原理和几个常用的算法实例
回溯算法原理和几个常用的算法实例回溯算法是一种通过不断尝试和回退的方式来进行问题求解的算法。
它的基本思想是在过程中，当发现当前的选择并不符合要求时，就进行回退，尝试其他的选择，直到找到符合要求的解或者遍历完所有可能的选择。
回溯算法通常用于问题求解中的和排列组合问题，比如求解八皇后问题、0-1背包问题、数独等。
下面将介绍几个常用的回溯算法实例。
1.八皇后问题：八皇后问题是指在一个8×8的国际象棋棋盘上，放置八个皇后，使得任意两个皇后都不在同一行、同一列或同一斜线上。
可以通过递归的方式依次尝试每一行的位置，并判断当前位置是否满足条件。
如果满足条件，则进入下一行尝试；否则回溯到上一行，并尝试其他的位置，直到找到解或遍历完所有的可能。
2.0-1背包问题：0-1背包问题是指在给定一组物品和一个容量为C的背包，每个物品都有自己的重量和价值，求解在不超过背包容量时，如何选择物品使得背包中物品的总价值最大。
可以通过递归的方式依次考察每个物品，并判断是否选择当前物品放入背包。
如果放入当前物品，则背包容量减小，继续递归考察下一个物品；如果不放入当前物品，则直接递归考察下一个物品。
直到遍历完所有物品或背包容量为0时，返回当前总价值。
3.数独问题：数独是一种通过填充数字的方式使得每一行、每一列和每一个九宫格内的数字都满足一定条件的谜题。
可以通过递归的方式依次尝试填充每一个空格，并判断当前填充是否符合条件。
如果符合条件，则继续递归填充下一个空格；如果不符合条件，则回溯到上一个空格，并尝试其他的数字，直到找到解或遍历完所有的可能。
回溯算法的时间复杂度一般较高，通常为指数级别。
因此，在实际应用中，可以结合剪枝等优化策略来提高算法的效率。
此外，回溯算法也可以通过非递归的方式进行实现，使用栈来存储当前的状态，从而避免递归带来的额外开销。
总之，回溯算法是一种非常有效的问题求解方法，通过不断尝试和回退，可以在复杂的空间中找到符合要求的解。
递归与回溯算法
1
递归的定义
所谓递归就是一个函数或过程可以直接或间接地调用自己。 我们大家都熟悉一个民间故事：从前有一座山，山上有一 座庙，庙里有一个老和尚正在给小和尚讲故事，故事里说， 从前有一座山，山上有一座庙，庙里有一个老和尚正在给 小和尚讲故事，故事里的故事是说……。象这种形式，我 们就可以称之为递归的一种形象描述，老和尚什么时候不 向下讲了，故事才会往回返，最终才会结束。 再如：前面多次提到的求N!的问题。 我们知道：当N>0时，N!=N*(N-1)!，因此，求N!的问题化成 了求N*(N-1)!的问题，而求(N-1)!的问题又与求N!的解法相同， 只不过是求阶乘的对象的值减去了1，当N的值递减到0时， N!=1，从而结束以上过程，求得了N!的解。
Begin If n=1 then FIB:=0 Else if n=2 then FIB:=1 Else FIB:=FIB(n-1)+FIB(n-2) End;
测试数据： 输入： 5 输出： 3
10
2．问题的求解方法是按递归算法来实现的。 例如；著名的Hanoi塔（汉诺塔）问题。
3．数据之间的结构关系按递归定义的 例如：大家将在后面的学习内容中遇到的树的 遍历、图的搜索等问题。
测试数据 输入： 34 输出： 125
18
例5:用辗转相除法求两个自然数m,n的最大公约数。
思路：辗转相除法规定：求两个正整数m,n （m>=n）的最大公约数，应先将m除以n；求得 余数r,如果等于零，除数n就是m,n的最大公约数； 如果r不等于零，就用n除以r，再看所得余数是否 为零。重复上面过程，直到余数r为零时，则上一 次的余数值即为m,n的最大公约数。用其数学方 式描述如下:
3
递归的调用
数独自动解题
数独自动解题简介数独是一种受欢迎的数字逻辑谜题，目标是将1到9的数字填入一个9x9的方格中，使得每行、每列和每个3x3的子方格中都包含唯一的数字。
对于那些喜欢解谜题的人来说，一款能够自动解题的数独程序将是非常方便的工具。
本文将介绍如何实现一个数独自动解题程序。
数独解题算法基本原理数独解题算法的基本原理是通过不断尝试填入数字，然后验证其合法性，直到找到解决方案为止。
下面是一个常见的数独解题算法流程：1.找到一个未填数字的空格（即值为0的格子）。
2.尝试将1到9的数字依次填入该空格。
3.验证填入数字后是否满足数独规则，即所填数字在同一行、同一列和同一子方格中都没有重复。
4.如果满足规则，继续尝试填入下一个空格。
5.如果不满足规则，回溯到上一个空格，尝试下一个数字。
6.重复步骤1到5，直到将所有空格均填满或找到一个解决方案。
递归回溯算法递归回溯算法是一种常用的解决数独问题的方法。
它通过递归地尝试不同的数字，并在遇到不满足规则的情况下进行回溯。
下面是一个简单的数独解题的递归回溯算法：def solve_sudoku(board):for i in range(9):for j in range(9):if board[i][j] == 0:for num in range(1, 10):if is_valid(board, i, j, num):board[i][j] = numif solve_sudoku(board):return Trueboard[i][j] = 0return Falsereturn Truedef is_valid(board, row, col, num):for i in range(9):if board[row][i] == num:return Falseif board[i][col] == num:return Falseif board[3*(row//3)+i//3][3*(col//3)+i%3] == num:return Falsereturn True示例和演示输入数独我们可以将数独问题表示为一个二维数组，其中0表示空格，其他数字表示已知的数字。
C语言高级特性递归与回溯算法
C语言高级特性递归与回溯算法C语言高级特性：递归与回溯算法递归和回溯算法是C语言中一种非常重要的高级特性，它们在解决一些复杂问题和优化代码时发挥着关键的作用。
本文将会介绍递归和回溯算法的原理和应用，并通过具体的示例来说明它们的使用方法。
一、递归算法递归是指一个函数在执行过程中调用自身的过程。
递归算法通常包括两个部分：递归出口和递归调用。
递归出口是指当满足某个条件时结束递归的条件，而递归调用则是指在函数内部调用自身来解决规模更小的问题。
递归算法在解决一些具有重复性结构的问题时非常高效。
例如，计算一个数的阶乘，可以使用递归算法来实现：```c#include <stdio.h>int factorial(int n) {if (n == 0 || n == 1) { //递归出口return 1;} else {return n * factorial(n - 1); //递归调用}}int main() {int n = 5;printf("The factorial of %d is %d\n", n, factorial(n));return 0;}```上述代码定义了一个计算阶乘的递归函数factorial。
在函数内部，通过递归调用来计算规模更小的问题，直到n等于0或1时返回结果。
二、回溯算法回溯算法是一种通过尝试所有可能的解来找到问题解决方法的搜索算法。
在遇到有多个解可选的情况下，回溯算法会尝试每一种可能，并通过剪枝策略来避免不必要的计算。
回溯算法通常涉及到构建决策树和遍历树上的节点。
以八皇后问题为例，考虑如何在8x8的棋盘上放置8个皇后，使得每个皇后都不会互相攻击。
下面是用回溯算法解决八皇后问题的示例代码：```c#include <stdio.h>#define N 8int board[N][N];int isSafe(int row, int col) {int i, j;// 检查当前位置的列是否安全for (i = 0; i < row; i++) {if (board[i][col] == 1) {return 0;}}// 检查当前位置的左上方是否安全for (i = row, j = col; i >= 0 && j >= 0; i--, j--) { if (board[i][j] == 1) {return 0;}}// 检查当前位置的右上方是否安全for (i = row, j = col; i >= 0 && j < N; i--, j++) { if (board[i][j] == 1) {return 0;}}return 1;}int solve(int row) {int col;if (row >= N) { // 所有行都已经安全放置皇后，找到解 return 1;}for (col = 0; col < N; col++) {if (isSafe(row, col)) {board[row][col] = 1; // 放置皇后if (solve(row + 1)) { // 递归调用return 1;}board[row][col] = 0; // 回溯，撤销放置皇后}}return 0;void printBoard() {int i, j;for (i = 0; i < N; i++) {for (j = 0; j < N; j++) {printf("%d ", board[i][j]); }printf("\n");}}int main() {if (solve(0)) {printf("Solution:\n");printBoard();} else {printf("No solution found.\n"); }return 0;}上述代码使用回溯算法来解决八皇后问题。
算法——回溯法
算法——回溯法回溯法回溯法有“通⽤的解题法”之称。
⽤它可以系统地搜索⼀个问题的所有解或任⼀解。
回溯法是⼀种即带有系统性⼜带有跳跃性的搜索算法。
它在问题的解空间树中，按深度优先策略，从根节点出发搜索解空间树。
算法搜索⾄解空间树的任⼀结点时，先判断该节点是否包含问题的解。
如果不包含，则跳过对以该节点为根的⼦树的搜索，逐层向其它祖先节点回溯。
否则，进⼊该⼦树，继续按照深度优先策略搜索。
回溯法求问题的所有解时，要回溯到根，且根节点的所有⼦树都已被搜索遍才结束。
回溯法求问题的⼀个解时，只要搜索到问题的⼀个解就可结束。
这种以深度优先⽅式系统搜索问题的算法称为回溯法，它是⽤于解组合数⼤的问题。
问题的解空间⽤回溯法解问题时，应明确定义问题的解空间。
问题的解空间⾄少包含问题的⼀个（最优）解。
例如对于有n种可选择物品的0-1背包问题，其解空间由长度为n的0-1向量组成。
该解空间包含对变量的所有可能的0-1赋值。
例如n=3时，其解空间是{(0,0,0),(0,0,1),(0,1,0),(0,1,1),(1,0,0),(1,0,1),(1,1,0),(1,1,1)}定义了问题的解空间后，还应该将解空间很好地组织起来，使得能⽤回溯法⽅便地搜索整个解空间。
通常将解空间组织成树或者图的形式。
例如，对于n=3时的0-1背包问题，可⽤⼀颗完全的⼆叉树表⽰其解空间，如下图。
解空间树的第i层到第i+1层边上的标号给出了变量的值。
从树根到叶⼦的任⼀路径表⽰解空间中的⼀个元素。
例如，从根节点到节点H的路径相当与解空间中的元素(1,1,1)。
回溯法的基本思想确定了解空间的组织结构后，回溯法从根节点出发，以深度优先搜索⽅式搜索整个解空间。
回溯法以这种⼯作⽅式递归地在解空间中搜索，直到找到所要求的解或解空间所有解都被遍历过为⽌。
回溯法搜索解空间树时，通常采⽤两种策略避免⽆效搜索，提⾼回溯法的搜索效率。
其⼀是⽤约束函数在当前节点（扩展节点）处剪去不满⾜约束的⼦树；其⼆是⽤限界函数剪去得不到最优解的⼦树。
回溯算法
三、回溯的一般步骤
回溯法正是针对这类问题，利用这类问题的
上述性质而提出来的比枚举法效率更高的算 法。
二、回溯的一般描述
procedure rbacktrack(k); begin if k > n then return else for each x(k)，如果x(k)∈t(x(1)…x(k-1))且 b(x(1)…x(k))=true do begin if x(1)…x(k)是一个解 then write(x(1)…x(k) else rbacktrack(k+1); end; end;
演示
一、回溯的概念
像走迷宫这样，遇到死路就回头的搜索思路
就叫做“回溯”。
从问题的某种可能情况出发，搜索所有能到
达的可能情况，然后以其中一种可能的情况 为新的出发点，继续向下探索，当所有可能 情况都探索过且都无法到达目标的时候，再 回退到上一个出发点，继续探索另一个可能 情况，这种不断回头寻找目标的方法称为 “回溯法”。
二、回溯的一般描述
可用回溯法求解的问题P，通常要能表达为：
对于已知的由n元组（x1，x2，…，xn）组成 的一个状态空间E={（x1，x2，…，xn） ∣xi∈Si ，i=1，2，…，n}，给定关于n元组 中的一个分量的一个约束集D，要求E中满足 D的全部约束条件的所有n元组。其中Si是分 量xi的定义域，且 |Si| 有限，i=1，2，…， n。我们称E中满足D的全部约束条件的任一 n元组为问题P的一个解。
骑士遍历
骑士遍历问题的解空间是从左下角到右上角
node、扩展节点）。 从E-节点可移动到一个新节点。 如果能从当前的E-节点移动到一个新节点，那么这个新 节点将变成一个活节点和新的E-节点，旧的E-节点仍是 一个活节点。 如果不能移到一个新节点，当前的E-节点就“死”了 （即不再是一个活节点），那么便只能返回到最近被考 察的活节点（回溯），这个活节点变成了新的E-节点。 当我们已经找到了答案或者回溯尽了所有的活节点时， 搜索过程结束。
回溯算法和递归的关系
回溯算法和递归的关系回溯算法和递归是两个在计算机科学中常用的概念，它们之间有着紧密的关系。
本文将从回溯算法和递归的定义、特点、应用以及它们之间的联系等方面进行阐述。
一、回溯算法与递归的定义回溯算法是一种通过不断地尝试所有可能的解决方案来找到问题解的方法。
它通常用于解决那些具有多个解的问题，其中每个解都需要满足一定的约束条件。
递归是一种自我调用的算法，通过将一个大问题拆分成一个或多个相同类型的小问题来解决。
递归算法在解决问题时，会不断地调用自身，直到达到基本情况，然后再一层一层地返回结果。
二、回溯算法与递归的特点1. 回溯算法的特点：- 回溯算法通过尝试所有可能的解，逐步构建问题的解空间，并在搜索过程中剪枝，以提高效率。
- 回溯算法通常采用深度优先搜索的方式，即先尝试最深的路径，然后再回溯到上一层。
- 回溯算法的时间复杂度通常较高，因为它需要遍历所有可能的解空间。
2. 递归的特点：- 递归算法可以将一个大问题化解成一个或多个相同类型的小问题，从而简化解决过程。
- 递归算法通常需要一个或多个基本情况，用来结束递归调用，否则可能陷入无限循环。
- 递归算法的时间复杂度通常较高，因为它需要不断地调用自身。
三、回溯算法与递归的应用1. 回溯算法的应用：- 八皇后问题：在一个8x8的棋盘上放置8个皇后，使得它们互相之间不能攻击到对方。
使用回溯算法可以找到所有可能的解。
- 0-1背包问题：有一组物品，每个物品有重量和价值，要求在不超过背包容量的情况下，选择一些物品放入背包，使得背包中物品的总价值最大。
使用回溯算法可以枚举所有可能的选择。
2. 递归的应用：- 阶乘计算：计算一个正整数的阶乘，可以使用递归算法，将问题拆分成更小的子问题。
- 斐波那契数列：计算斐波那契数列的第n项，可以使用递归算法，将问题拆分成计算前两项的子问题。
四、回溯算法与递归的联系回溯算法和递归有着密切的联系，它们之间存在着相互调用的关系。
在回溯算法中，通常会使用递归来实现对解空间的搜索。
递归算法经典题目
递归算法经典题目递归算法是一种非常强大的编程技术，它能够解决一些复杂的问题，将它们分解为更小的子问题。
以下是一些经典的递归算法题目：1. 斐波那契数列：这是一个经典的递归问题，斐波那契数列中的每个数字都是前两个数字的和。
例如，0, 1, 1, 2, 3, 5, 8, 13, 21... 编写一个函数来计算斐波那契数列中的第n个数字。
2. 阶乘：阶乘是一个数的所有小于及等于该数的正整数的乘积。
例如，5的阶乘（记作5!）是5 4 3 2 1 = 120。
编写一个函数来计算一个数的阶乘。
3. 二分搜索：二分搜索是一种在排序数组中查找特定元素的搜索算法。
编写一个函数，该函数使用二分搜索在给定的排序数组中查找特定的元素。
4. 回溯算法：回溯算法用于解决决策问题，例如八皇后问题。
在这个问题中，我们需要在一个8x8棋盘上放置8个皇后，使得任何两个皇后都不在同一行、同一列或同一对角线上。
编写一个使用回溯算法解决八皇后问题的函数。
5. 合并排序：合并排序是一种分治算法，它将一个大的列表分成两个较小的子列表，对子列表进行排序，然后将它们合并成一个已排序的列表。
编写一个使用递归实现合并排序的函数。
6. 快速排序：快速排序也是一种分治算法，它选择一个"基准"元素，然后将所有比基准小的元素放在其左边，所有比基准大的元素放在其右边。
然后对左右两个子列表进行快速排序。
编写一个使用递归实现快速排序的函数。
7. 深度优先搜索（DFS）：这是一种用于遍历或搜索树或图的算法。
这个算法会尽可能深地搜索树的分支。
当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。
这一过程一直进行到已发现从源节点可达的所有节点为止。
如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。
编写一个使用递归实现深度优先搜索的函数。
这些题目都可以帮助你理解和应用递归算法。
n皇后问题_回溯法_递归实现__解释说明
n皇后问题回溯法递归实现解释说明1. 引言1.1 概述本文主要讨论的是n皇后问题及其解决方法。
n皇后问题是一个经典的数学问题，旨在找到如何将n个皇后放置在一个nxn的棋盘上，使得所有皇后彼此之间不会互相攻击。
这个问题具有一定难度，但可以通过回溯法和递归实现来有效解决。
1.2 文章结构本文共分为五个部分：引言、n皇后问题、回溯法解决n皇后问题的步骤、递归实现n皇后问题解决方案的详细步骤与算法思路以及结论。
引言部分主要对文章内容进行概述和介绍，并给出本文的结构安排。
1.3 目的本文旨在通过对n皇后问题的深入研究和探讨，介绍回溯法和递归实现在解决该问题中的应用方法。
通过详细说明算法步骤和思路，帮助读者理解如何使用回溯法和递归实现有效地解决n皇后问题，并对两种方法进行评价与讨论。
同时，还展望了可能的未来研究方向，为读者提供更多思考和拓展的空间。
本文旨在为对n皇后问题感兴趣的读者提供有益的参考和指导。
（文章引言部分完）2. n皇后问题:2.1 问题描述:n皇后问题是一个经典的组合问题，其中n表示棋盘上的行数和列数。
在一个nxn的棋盘上，要放置n个皇后，并且要求任意两个皇后之间不得互相攻击（即不能处于同一行、同一列或同一对角线上）。
这是一个相当困难的问题，因为随着n的增大，可能的解法呈指数增长。
2.2 解决方法介绍:为了解决n皇后问题，可以使用回溯法和递归实现的组合算法。
回溯法是一种通过尝试所有可能情况来找到解决方案的方法。
它通过逐步构建解，并在遇到无效解时进行回溯。
而递归是把大规模的问题分解成相似但规模更小的子问题来求解。
2.3 回溯法和递归实现的关系:在解决n皇后问题中，回溯法是主要思想，而递归则用于辅助实现回溯过程。
在每一步尝试放置一个皇后时，会先判断该位置是否与之前已经放置好的皇后冲突。
如果没有冲突，则继续考虑下一个位置，并以递归的方式调用自身。
如果找到一个有效解时，会结束递归并返回结果。
如果所有位置都无法放置皇后，则回溯至上一步进行下一种尝试。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Function jiech(n:integer):longint; Begin if n=0 then jiech:=1 else jiech:=n*jiech(n-1); End;
2
爬楼梯时可以1次走1个台阶，也可以1次走2个台阶。对 于由n个台阶组成的楼梯，共有多少种不同的走法？
1个台阶：只有1种走法； 2个台阶：有两种走法；(1+1；2) N个台阶(n>2)，记走法为f(n)： 第1次走1个台阶，还剩(n-1)个台阶，走法为f(n-1)； 第1次走2个台阶，还剩(n-2)个台阶，走法为f(n-2)。 所以，f(n)=f(n-1)+f(n-2)。 定义f(0)=1，则有： Function n 0 fib(n:integer):longint; 1 f (n) 1 n 1 Begin f (n 1) f (n 2) n 1 if(n=0)or(n=1)then fib:=1 else fib:=fib(n-1)+fib(n-2); 3 End;
1 n 1或m 1 q(n, n) m n q(n, m) n 1 q(n, n 1) m q(n, m 1) q(n m, m) n m 1
Function q(n,m:integer):integer; Begin if(n<1)or(m<1) then exit(0); if(n=1)or(m=1) then exit(1); if n<m then exit(q(n,n)); if n=m then exit(q(n,m-1)+1); exit(q(n,m-1)+q(n-m,m)); End;{正整数n的划分数p(n)=q(n,n)。}
15
搜索算法 信息学奥赛的试题一般有两种类型： 1.简明的数学模型揭示问题本质。对于这一类试题，我们 尽量用解析法求解。 2.对给定的问题建立数学模型，或即使有一定的数学模型， 但采用数学方法解决有一定的困难。对于这一类试题，我 们只好用模拟或搜索求解。 尽管搜索的时间复杂度一般是指数级的，但在缺乏解决问 题的有效模型时，搜索却是一种行之有效的解决问题的基 本方法，而且使用搜索算法解决问题时，在实现过程中有 很大的优化空间。信息学奥赛中考察搜索算法，一是考察 选手算法运用能力，二是考察选手算法优化能力。 枚举法（穷举法） 回溯（深度优先搜索） 16 广度优先搜索
14
program hannuota; var n:integer; tot:longint; procedure hanoi(n:integer;s,t,d:char); begin if n>0 then begin hanoi(n-1,s,d,t); tot:=tot+1; writeln(s,’->’,d); hanoi(n-1,t,s,d); end; end; begin readln(n); tot:=0; hanoi(n,’A’,’B’,’C’); writeln(tot); end.
枚举法的基本思想是根据提出的问题枚举所有可能状 态，并用问题给定的条件检验哪些是需要的，哪些是不 需要的。能使命题成立，即为其解。虽然枚举法本质上 属于搜索策略，但是它与后面讲的回溯法有所不同。因 为适用枚举法求解的问题必须满足两个条件： (1) 可预先确定每个状态的元素个数n； (2) 状态元素a1，a2，…，an的可能值为一个连续的值域。 设:ai1—状态元素ai 的最小值；aik—状态元素ai 的最大值 (1≤i≤n) ， 即 a11≤a1≤a1k ， a21≤a2≤a2k ， ai1≤ai≤aik ， …… ， an1≤an≤ank for a1←a11 to a1k do fo a2←a21 to a2k do …………………… for ai←ai1 to aik do …………………… for an←an1 to ank do if 状态(a1，…，ai，…，an)满足检验条件 17 then 输出问题的解；
递归与回溯算法
1
递归的定义： 在定义一个过程或函数时出现调用本过程或本函数的成 分，称为递归。若调用自身，称为直接递归。若过程或 函数p调用过程或函数q，而q又调用p，则称为间接递归。 在程序设计中，使用递归技术往往使函数的定义和算法 的描述简洁且易于理解。 递归的使用： 1.定义是递归的
n0 1 n! n * (n 1)! n 0
S E ND +MOR伯数字，找出能使等式成立的所有 数字组合。
直接枚举 S、E、N、D、M、O、R、Y分别从0..9范围内尝试每个取 值可能，共有108种组合需要判断 。
观察算式的形式，根据加法运算的特点可知： M=1,进一步分析，O＝0,S=9, 因此只需枚举判断75种组合即可。
8
递归过程或函数直接（或间接）调用自身，但如果 仅有这些操作，那么将会由于无休止地调用而引起死循 环。因此一个正确的递归程序虽然每次调用的是相同的 子程序，但它的参数、输入数据等均有所变化，并且在 正常的情况下，随着调用的深入，必定会出现调用到某 一层时，不再执行调用而是终止函数的执行。
递归思路是把一个不能或不好直接求解的“大问题” 转化成一个或几个“小问题”来解决，再把这些“小问 题”进一步分解成更小的“小问题”来解决，如此分解， 直至每个“小问题”都可以直接解决。 递归分解不是随意地分解，要保证“大问题” 和“小问题”相似。 例：采用递归算法求实数数组A[0..n]中的最小值。
3.问题的求解方法是递归的 例：整数划分问题（版本1） 为避免重复，记 n 1 2
1
n n n， 其中 n n n 1
k 2
k
设f(n,k)为把正整数n分成k份的分法，那么： 先考虑特殊情况： (1)f(n,1)=1 (n=n) (2)f(n,n)=1 (n=1+1+……+1) (3)当k>n时， f(n,k)=0 (4)若n1=1，则：
10
function min(i,j:integer):real; var mid:integer; min1,min2:real; begin if i=j then min:=a[i] else begin mid:=(i+j) div 2; min1:=min(i,mid); min2:=min(mid+1,j); if min1<min2 then min:=min1 else min:=min2; end; end;
6
整数划分问题（版本2） 在正整数n的所有不同的划分中，将最大加数n1不大于m 的划分个数记作q(n,m)。我们可以建立如下的递归关系。 (1) q(n,1)=1, n>=1； 当最大加数n1不大于1时，任何正整数n只有一种划分 形式，即： n=1+1+……+1。 (2) q(n,m)=q(n,n)，m>=n； 最大加数n1实际上不能大于n。因此，q(1,m)=1。 (3) q(n,n)=1+q(n,n-1)； 正整数n的划分有n1=n的划分和n1<=n-1的划分组成。 (4) q(n,m)=q(n,m-1)+q(n-m,m)，n>m>1; n的最大加数n1不大于m的划分由n1=m的划分和 7 n1<=m-1的划分组成。
n n
2
k
n 1 ，且 n2 nk 1
5
其分法为f(n-1,k-1)；
(5)若n1>1,则 (n1 1) (n2 1) (nk 1) n k 0
记 n1 n1 1, n2 n2 1, ， k nk 1 n
2.有些数据结构是递归定义的，采用递归的方法编写算法 既方便又有效。如单链表： Type node=^lnode lnode=record data:integer; next:node; end;
求一个不带头结点的单链表head的所有data域之和的 递归算法如下： Function sum(head:node):integer; Begin if head=nil then sum:=0 else sum:=head^.data+sum(head.next); 4 End;
9
算法1:设f(a,i)为数组元素a[0]..a[i]中的最小值。当i=0时， 有f(a,i)=a[0]；假设f(a,i-1)已求出，则：
i a[0] 当 0时 f ( a, i ) min( f (a, i 1), a[i]) 其他情况
算法2：设f(i,j)为a[i]..a[j]中的最小值。将a[0]..a[n]看作一 个线性表，它可以分解成a[0]..a[i]和a[i+1]..a[n]两个子表， 分别求得各自的最小值x和y，较小者就是a[0]..a[n]中的最 小值。而求解子表中的最小值方法与总表相同，即再分 别把它们分成两个更小的子表，如此不断分解，直到表 中只有一个元素为止(该元素就是该表中的最小值)。
汉诺塔问题： 有n个半径各不相同的圆盘，按半径从大到小，自 下而上依次套在A柱上，另外还有B、C两根空柱。要求 将A柱上的n个圆盘全部搬到C柱上去，每次只能搬动一 个盘子，且必须始终保持每根柱子上是小盘在上，大盘 在下。输出总共移动的次数及移动方案。
A
B
C
13
• 分析：在移动盘子的过程当中发现要搬动n个 盘子，必须先将前n-1个盘子从A柱搬到B柱 去，再将A柱上的最后一个盘子搬到C柱，最 后从B柱上将n-1个盘子搬到C柱去。搬动n个 盘子和搬动n-1个盘子时的方法是一样的，递 归处理。当只需搬一个盘子时，直接搬动， 不需要递归。
19
以4皇后为例：
20
回溯法的基本思想为： 在按某种搜索策略的搜索过程中，在 某种状态，继续往前搜索已经确定不会得 到正确答案的情况下，我们可以返回上一 搜索状态，去沿新的可能性继续搜索。要 回溯到上一状态，则说明我们在前进中的 状态必须保存下来，我们采用“栈”来存 放。