第6章_递归

最新推荐文章于 2022-05-20 15:56:09 发布
最新推荐文章于 2022-05-20 15:56:09 发布
阅读量1.2k 收藏 17
点赞数 5
分类专栏： C语言版数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwww_com/article/details/77968905
版权

递归算法不是一种数据结构,而是一种有效的算法设计方法。

递归的概念

若一个算法直接地或间接地调用自己本身，则称这个算法是递归算法。
递归算法 用把问题分解为形式更加简单的子问题的方法来求解问题。递归算法既是一种有效的分析问题的方法，也是一种有效的算法设计方法。递归算法是解决许多复杂应用问题的重要方法。

递归算法的执行过程

例1：
计算阶乘函数的递归算法，并给出n = 3时递归算法的执行过程。

#include <stdio.h>

long int Fact(int n)
{
    long int y;
    if(n < 0)
    {
        printf("非法参数！");
        return -1;
    }

    if(n == 0) return 1;
    else
    {
        y = Fact(n - 1);        //递归调用
        return n * y;
    }
}


void main(void)
{
    long int fn;
    fn = Fact(3);
    printf("%d\n",fn);
}
//6

这里写图片描述
例2:
给出在有序数组a中查找数据元素x是否存在的递归算法
设计:算法的参数包括:有序数组a,要查找的数据元素x，数组下界下标low，数组上界下标high。当在数组a中查找到数据元素x时，函数返回数组a的下标；当在数组a中查找不到数据元素x时，函数返回-1。

#include <stdio.h>

int BSearch(int a[],int x,int low,int high);

void main(void)
{
    int a[] = {1,3,4,5,17,18,31,33};
    int x = 17;
    int bn;
    bn = BSearch(a,x,0,7);
    if(bn == -1) printf("x=%d,不在数组a中",x);
    else
        printf("x=%d,在数组a中下标为%d",x,bn);
    printf("\n");
}


int BSearch(int a[],int x,int low,int high)
{
    int mid;
    if(low > high) return -1;   //查找不成功

    mid = (low + high) / 2;
    if(x == a[mid]) return mid; //查找成功
    else if(x < a[mid])
    {
        return BSearch(a,x,low,mid - 1);
    }
    else
    {
        return BSearch(a,x,mid + 1,high);
    }
}

这里写图片描述

递归算法的设计方法

递归算法既是一种有效的算法设计方法，也是一种有效的分析问题的方法。递归算法求解问题的基本思想是：对于一个较为复杂的问题，可把原问题分解成若干个相对简单且类同的子问题，这样，较为复杂的原问题就变成了相对简单的子问题，而简单到一定程序的子问题可以直接求解。这样，原问题就可得到解了。
并不是每个问题都适宜于用递归算法求解。适宜于于用递归算法求解的问题的充分必要条件是：
1） 问题具有某种可借用的类同自身的子问题描述的性质
2） 某一有限步的子问题（也称作本原问题）有直接的解存在。
当一个问题存在上述两个基本要素时，设计该问题的递归算法的方法是：
1） 把对原问题的求解设计成包含有对子问题求解的形式；
2） 设计递归出口

例3：
设计模拟汉诺塔问题求解过程的算法。汉诺塔问题的描述是：设有三根标号为A，B，C的柱子，在A柱上放着n个盘子，每一个都比下面的略小一点，要求把A柱上的盘子全部移到C柱上，移动的规则是：a.一次只能 移动一个盘子；b.移动过程中大盘子不能放在小盘子上面；c.在移动过程中盘子可以放在A，B，C的任意一个柱子上。

问题分析：可以用递归方法求解n个盘子的汉诺塔问题。基本思想是：一个盘子的汉诺塔问题可直接移动。n个盘子的汉诺塔问题可递归表示为，首先把上边的n-1个盘子从A柱移动B柱，然后把最下边的一个盘子子A柱移到C柱，最后把移到B柱的n-1个盘子再移到C柱。

这里写图片描述
汉诺塔在线小游戏^V^,同学先感受一下吧http://www.4399.com/flash/109504_1.htm
设计：
首先，盘子的个数n是必须的一个输入参数，对n个盘子，可从上至下依次编号为1，2，…，n；其次，输入参数还需有三个柱子的代号，令三个柱子的参数名分别为fromPeg，auxPeg和toPeg；最后，汉诺塔问题的求解是一个处理过程，因此算法的输出是n个盘子从柱子fromPeg借助柱子auxPeg移动到柱子toPeg的移动步骤。设计每一步的移动为屏幕显示如下形式的信息：
Move Disk I from Peg X to Peg Y

#include <stdio.h>


void towers(int n,char fromPeg,char toPeg,char auxPeg);

void main(void)
{
    towers(4,'A','C','B');
}

void towers(int n,char fromPeg,char toPeg,char auxPeg)
{
    if(n == 1)
    {
        printf("%s%c%s%c\n","Move Disk 1 From Peg ",fromPeg," To Peg ",toPeg);
        return ;
    }

    //把n-1个圆盘从fromPeg借助toPeg移至auxPeg
    towers(n -  1,fromPeg,auxPeg,toPeg);

    //把圆盘n由fromPeg直接移至toPeg
    printf("%s%d%s%c%s%c\n","Move Disk ",n," From Peg ",fromPeg," To Peg ",toPeg);

    //把n-1个圆盘从auxPeg借助fromPeg移至toPeg
    towers(n - 1,auxPeg,toPeg,fromPeg);
}

这里写图片描述

递归算法到非递归算法的转换

有些问题需要用低级程序设计语言来实现,而低级程序设语言(如汇编语言)一般不支持递归,此时需要采用问题的非递归结构算法。一般来说，存在如下两种情况的递归算法：
1） 存在不借助堆栈的循环结构的非递归算法，如阶乘计算问题、斐波那契数列的计算问题、折半查找问题等。
2） 存在借助堆栈的循环结构的非递归算法，所有递归算法都可以借助堆栈转换成循环结构的非递归算法

对于第一种情况可直接用循环结构的算法
对于第二种，可以把递归算法转换成相应的非递归算法，此时，有两种转换方法：一种方法是借助堆栈，用非递归算法形式化模拟递归算法的执行过程；二种方法是根据要求解问题的特点，设计借助堆栈的循环结构算法。这两种方法都需要使用堆栈，这是因为堆栈的后进先出特点正好与递归函数的运行特点相吻合。

例4:
计算斐波那契数列Fib(n)问题.

#include <stdio.h>

long Fib2(int n);

void main(void)
{
    int i = 0;
    for(i = 0;i < 10; i++)
        printf("Fib(%d)=%d\n",i,Fib2(i));
}

long Fib2(int n)
{
    long int oneBack,twoBack,current;
    int i;
    if(n == 0 || n == 1) return n;
    else
    {
        oneBack = 1;
        twoBack = 0;
        for(i = 2;i <= n; i++)
        {
            current = oneBack + twoBack;
            twoBack = oneBack;
            oneBack = current;
        }
        return current;
    }
}

这里写图片描述

例5：
借助堆栈模拟系统的运行时栈，把汉诺塔问题的递归算法 转换为非递归算法。
SeqStack.h

//顺序堆栈结构体定义
typedef struct 
{
    DataType stack[MaxStackSize];
    int top;
}SeqStack;

//1.初始化
void StackInitiate(SeqStack*S)
{
    S->top = 0;
}

//2.判断是否为空
int StackNotEmpty(SeqStack S)
{
    //判断顺序堆栈S非空否，非空返回1，否则返回0
    if(S.top <= 0) return 0;
    else return 1;
}

//3.入栈
int StackPush(SeqStack*S,DataType x)
{
    //把数据元素值x压入顺序堆栈S,入栈成功返回1，否则返回0
    if(S->top >= MaxStackSize)
    {
        printf("堆栈已满无法插入！\n");
        return 0;
    }
    else
    {
        S->stack[S->top] = x;
        S->top++;
        return 1;
    }
}

//4.出栈
int StackPop(SeqStack*S,DataType*d)
{
    //弹出顺序堆栈S的栈顶数据元素值到参数d，出栈成功返回1，否则返回0
    if(S->top <= 0)
    {
        printf("堆栈已空无数据元素出栈！\n");
        return 0;
    }
    else
    {
        S->top--;
        *d = S->stack[S->top];
        return 1;
    }
}

//5.取栈顶数据元素
int StackTop(SeqStack S,DataType*d)
{
    if(S.top <= 0)
    {
        printf("堆栈已空！\n");
        return 0;
    }
    else
    {
        *d = S.stack[S.top - 1];
        return 1;
    }
}

Main

#include <stdio.h>
typedef struct 
{
    int retAddr;            //代表返回地址的数值
    int nPara;              //参数1
    char fromPegPara;       //参数2
    char toPegPara;         //参数3
    char auxPegPara;        //参数4
} DataType;
#define MaxStackSize 1000
#include "SeqStack.h"


/*
把n个盘子从fromPeg柱借助auxPeg柱移到toPeg柱
*/
void SimTowers(int n,char fromPeg,char toPeg,char auxPeg);

void main(void)
{
    SimTowers(4,'A','C','B');
}

void SimTowers(int n,char fromPeg,char toPeg,char auxPeg)
{
    DataType currarea;
    SeqStack s;
    char temp;
    int i;
    StackInitiate(&s);  //堆栈初始化

    //当前工作区初始化
    currarea.nPara = n;
    currarea.fromPegPara = fromPeg;
    currarea.toPegPara = toPeg;
    currarea.auxPegPara = auxPeg;
    currarea.retAddr = 1;
    StackPush(&s,currarea);

    //递归出口
start:
    if(currarea.nPara == 1)
    {
        printf("%s%c%s%c\n","Move Disk 1 from  Peg ",currarea.fromPegPara," To Peg ",currarea.toPegPara);
        i = currarea.retAddr;
        StackPop(&s,&currarea);
        switch(i)
        {
        case 1:goto label1;
        case 2:goto label2;
        case 3:goto label3;
        }
    }

    //递归自调用过程
    StackPush(&s,currarea);
    currarea.nPara--;
    temp = currarea.auxPegPara;
    currarea.auxPegPara = currarea.toPegPara;
    currarea.toPegPara = temp;
    currarea.retAddr = 2;
    goto start;

    //以下模拟返回第一次递归调用
label2:
    printf("%s%d%s%c%s%c\n","Move Disk ",currarea.nPara," From Peg ",currarea.fromPegPara," To Peg ",currarea.toPegPara);
    StackPush(&s,currarea);
    currarea.nPara--;
    temp = currarea.fromPegPara;
    currarea.fromPegPara = currarea.auxPegPara;
    currarea.auxPegPara = temp;
    currarea.retAddr = 3;
    goto start;

    //以下模拟返回第二次归调用
label3:
    i = currarea.retAddr;
    StackPop(&s,&currarea);
    switch(i)
    {
    case 1:goto label1;
    case 2:goto label2;
    case 3:goto label3;
    }


    //以下模拟返回主调函数
label1:
    return ;
}

这里写图片描述
例6：
设计一个输出如下形式数值的递归算法。
这里写图片描述
设计：
问题分析：该问题可以看成由两部分组成：一部分是输出一行值为n的数值；另一部分是原问题的子问题，其参数为n-1。当参数减到0时不再输出任何数据值，因此，递归的出口是当参数n<=0时空语句返回。

#include <stdio.h>

void Display(int n)
{
    int i;
    for(i = 1;i <= n; i++)
        printf("%d ",n);
    printf("% \n");
    if(n > 0) Display(n-1);
}

void main(void)
{
    Display(5);
}

方法二：

#include <stdio.h>

void Display(int n)
{
    int i,j;
    for(i = 1;n >= i; n--)
    {
        for(j = 1;j <= n; j++)
            printf("%d ",n);
        printf("\n");
    }
}

void main(void)
{
    Display(5);
}

这里写图片描述
例7：
求两个正整数n和m最大公约数

#include <stdio.h>

int Gcd(int n,int m)
{
    if(n < 0 || m < 0) exit(0);

    if(m == 0) return n;
    else if(m > n) return Gcd(m,n);
    else return Gcd(m,n%m);
}

void main(void)
{
    int n = 30,m = 4;
    printf("%d与%d最大公约为%d\n",n,m,Gcd(n,m));
}

方法二:

#include <stdio.h>

int Gcd(int n,int m)
{
    int tn,tm,temp;
    if(n < 0 || m < 0) exit(0);

    if(m > n)
    {
        tn = m;
        tm = n;
    }
    else
    {
        tn = n;
        tm = m;
    }
    while(tm != 0)
    {
        temp = tn;
        tn = tm;
        tm = temp % tm;
    }
    return tn;  //返回最大公约数
}

void main(void)
{
    int n = 30,m = 4;
    printf("%d与%d最大公约为%d\n",n,m,Gcd(n,m));
}

这里写图片描述

回溯法-设计举例

例：
设计求解迷宫问题的算法并用实际例子测试。迷宫是一些互相连通的交叉路口的集合，给定一个迷宫入口，一个迷宫出口，当从入口到出口存在通路时输出其中的一条通路，当从入口到出口不存在通路时输出无通路存在。每个交叉路口除进来的路外还有三个路口，分别是向左、向前和向右。为简化设计，假设迷宫中不存在环路。如图
这里写图片描述

Maz1.dat

6
0 2 0
3 5 6
0 0 4
0 0 0
0 0 0
7 0 0
7

Maze.h

typedef struct      //路口结构体定义
{
    int left;       //向左方向
    int forward;    //向前方向
    int right;      //向右方向
} InterSection;

typedef struct 
{
    int mazeSize;           //路口个数
    InterSection * intSec;  //路口集合
    int Exit;               //出口
} Maze;

/*
回法搜索迷宫m的所有分支，输入参数currSetValue为当前所处的路口
  */
int TravMaze(Maze* m,int currSetValue)
{
    //currSetValue>0为有路径存在，可以继续控索发现一条路径
    if(currSetValue > 0)
    {
        if(currSetValue == m->Exit)             //递归出口
        {
            printf("%d <==",currSetValue);      //输出路口号
            return 1;
        }
        //向左探索
        else if(TravMaze(m,m->intSec[currSetValue].left) == 1)
        {
            printf("%d <==",currSetValue);
            return 1;
        }
        //向前探索
        else if(TravMaze(m,m->intSec[currSetValue].forward) == 1)
        {
            printf("%d <==",currSetValue);
            return 1;
        }
        //向右探索
        else if(TravMaze(m,m->intSec[currSetValue].right) == 1)
        {
            printf("%d <==",currSetValue);
            return 1;
        }
    }
    return 0;
}

//按文件Filename中存放的数据创建迷宫
void CreatMaze(char* filename,Maze* m)
{
    FILE* fp;
    int i;
    fp = fopen(filename,"r");       //打开路口数据文件
    if(!fp)
    {
        printf("数据文件无法打开！");
        return ;
    }
    fscanf(fp,"%d",&m->mazeSize);   //读入路口个数
    //建立mazeSize+1个元素的数组
    m->intSec = (InterSection*)malloc(sizeof(InterSection)*(m->mazeSize+1));

    for(i = 1;i <= m->mazeSize; i++)//读入全部路口的结构体数值
    {
        fscanf(fp,"%d%d%d",&m->intSec[i].left,&m->intSec[i].forward,&m->intSec[i].right);
    }
    fscanf(fp,"%d%d%d",&m->Exit);   //读入出口数据
    close(fp);                      //关闭文件资源
}

Main.c

#include <stdlib.h>
#include <stdio.h>
//数据放到资源文件Maze1.dat中
#include "Maze.h"

void main(void)
{
    Maze m;
    int start = 1;
    CreatMaze("Maze1.dat",&m);
    if(TravMaze(&m,start))
        printf("\n此迷宫的一条通路如上所示！");
    else
    {
        printf("\n此迷宫无通路！");
    }
}

这里写图片描述

OS_windows7
关注
  • 5
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
递归实现“打印从1到N的整数”
Nangua_Crisp的博客
12-06 4740
#include<stdio.h> int printN(int N); int main() { int n=0; scanf("%d",&n); printN(n); return 0; } int printN(int N) { if(N>0){ printf("%d\n",printN(N-1)); } return N+1; } 相比于循环实现，递归实现的代码要简洁很多。如果需要实现打印从N到1，或者隔一个数字打印一次等需求，也只需要很小的代码调整即.
汉诺塔移动过程c语言,汉诺塔移动过程（C语言）
weixin_34800530的博客
05-24 559
分析：假设我们在A柱子上有8个圆盘需要移动到C柱子上面，那么利用递归思想，我们只需要先将上面的7个圆盘移动到B柱子上，然后将最底下的圆盘移动到C柱子上，再将B柱子上的圆盘移动到C柱子上，此时，A盘已经空着了，就变成了辅助柱子。具体代码：#include void HanoiTower(int n, char source, char temp, char target) {if (n < 1...
和为s的两个数字
weixin_44764207的博客
10-05 1934
题目描述 输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。 示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[2,7] 或者 [7,2] 示例 2： 输入：nums = [10,26,30,31,47,60], target = 40 输出：[10,30] 或者 [30,10] 实现代码 public static int[] twoSum(int[] nums, int target
汉诺塔问题
lingfeng892的专栏
05-13 2372
初学数据结构，这个是书上的例子 总移动 2^n - 1次 #include #include int main() { void Towers(int,char,char,char); //前视定义 Towers(4,'A','C','B'); return 0; } void Towers(int n,char fromPeg,ch
用C语言编写一个递归函数，能正序输出一个多位整数的各位数字。（附有详细代码）
m0_58941767的博客
08-09 4726
使用递归函数，正序输出数值的各位数 比如输入123546，得到 1 2 3 4 5 6的正序数字 代码如下： #include<stdio.h> void printDigit(int data) { if(data==0) return; printDigit(data/10); printf("%d ",data%10); } int main() { int n; scanf("%d",&n); printDigit(n); return 0; }
第六章函数_自定义库_嵌套递归.dev
11-16
第六章函数_自定义库_嵌套递归.dev
Desktop_C++_算法导论_矩阵乘法_递归_
10-03
在本项目中，我们主要探讨的是C++编程语言中的矩阵乘法算法，特别是基于《算法导论》第六版第四章77页所描述的递归方法。递归是一种强大的编程技术，它允许函数调用自身来解决问题。在这个特定的场景中，递归被用来...
数据结构：第6章 递归.pdf
06-12
递归算法与数据结构 递归（Recursion）是指在函数定义中调用自己本身的编程技巧。递归函数可以将复杂的问题分解成更小的子问题，直到解决最简单的子问题，从而解决整个问题。递归算法广泛应用于数据结构、算法设计...
第7章_二叉树.pptx
最新发布
08-23
* 性质1：一棵非空二叉树的第i层上至多有2i-1个结点。 * 性质2：深度为h的二叉树至多有2h-1个结点。 * 性质3：对于任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1。 * 性质4：对于完全二叉树...
马丙鹏_计算机算法设计与分析_第六章__21
08-04
在《计算机算法设计与分析》第六章中，马丙鹏详细讲解了回溯法的应用，并通过几个经典实例进行了解释。 首先，6.1 一般方法介绍了回溯法的基本思想和步骤。回溯法通常包括以下步骤： 1. 定义问题的解空间：这通常是...
吉林大学超星慕课《高级程序语言设计》实验06 递归程序设计（2020级）
qq_41722392的博客
12-07 2184
代码仅供参考，欢迎一起交流！1 题目名称：排列组合2 题目名称：Hermite多项式3 题目名称：Ackerman函数4 题目名称：最大公因数5 题目名称：顺序检索6 题目名称：最大元素7 题目名称：数组反序8 题目名称：截木条 1 题目名称：排列组合 问题描述：编写程序求函数C(m,n)的值。 输入：从键盘随机输入一个自然数和一个非负整数，分别作为m和n的值（m≥n）。 输出：函数C(m,n)的值。 样例1： 输入： 4 1 输出： 4 样例2： 输入： 6 2 输出： 15 #include &lt
程序设计2递归
zhaoliguaner的博客
04-10 208
一、用递归解决递归形式的问题 1、波兰表达式（前缀）本身就是一个递归的定义（像树一样），所以用递归来写代码~ 定义：满足如下为波兰表达式 （1）输入形式为一个数 a （2）输入形式为 运算符 波兰表达式 波兰表达式 #include<iostream> #include<cstdio> #include<cstdlib> using na...
递归之汉诺塔算法
热门推荐
qq_47897078的博客
05-20 1万+
汉诺塔问题详解 如果你有耐心翻到这里看到这个回答，相信大部分前面的回答并没有让你完全明白汉诺塔的递归算法应该怎么理解，那么我希望这个答案会是你浏览的最后一个(不知道怎么打删除线…)。ps：篇幅稍微有点长，请耐心阅读，相信我，会有价值的。（毕竟是个人理解，若其中有不正确的地方望大家多多指正哈） 要用程序来解决这个问题，我们先定义一个移动函数：**move（移动数，开始柱，中转柱，目标柱），**例如 move（2，A，B，C） 表示将2个盘子从A柱（开始柱）借助B柱（中转柱）移动到C柱（目标柱）。 关于开始柱，
算法分析设计--递归算法
日拱一卒,功不唐捐
05-18 3753
What’s the 递归算法 定义： 程序直接或间接调用自身的编程技巧称为递归算法（Recursion）。 一个过程或函数在其定义或说明中又直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量 特点： 任何一个可以用计算机求解的问题所需的计算时间都与其规模n有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。 分治法的设计思想是，将一个难以直接解决的大问题
递归算法设计技术
LixDemon的博客
03-12 1430
递归算法设计技术递归的定义需要满足的条件何时使用递归递归模型递归算法的执行过程递归算法设计递归数据结构及其递归算法设计单链表的递归算法设计二叉树的递归算法设计基于归纳思想的递归算法设计 递归的定义 在定义一个过程或函数时出现调用本过程或本函数的成分。称之为递归。 若调用自身，称之为直接递归。若过程或函数p调用过程或函数q，而q又调用p，称之为间接递归。 任何间接递归都可以等价地转换为直接递归。 如...
算法设计与分析——递归算法
qq_52434831的博客
04-20 1817
一 概念解释 递归（recursive）定义为一种直接或间接引用自身的定义方法，通俗的说，即是：自己调用自己的函数（或称为方法）。 二 递归算法结构 一个合法的递归包括两个部分：基础情况和递归部分。基础情况以直接形式明确列举新事物的若干简单对象，递归部分给出由简单（或较简单）对象定义新的条件和方法。 三 算法思想内核 在程序设计中，处理重复性计算最常用的方法是组织迭代循环，此外还可以采用递归计算的方法，后者在非数值计算领域适用性更强。递归本质也是一种循环，将较复杂的计算或问题不断分解为较简单的子部分，
c语言递归练习习题
漫鱼
03-15 6426
求第n个斐波那契数 求n的k次方 输入一个非负整数，返回组成它的数字之和，例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19 递归实现字符串反转 递归和非递归分别实现strlen 递归求n的阶乘 递归方式实现正序打印一个整数的每一位 求第n个斐波那契数 #define _CRT_SECURE_NO_WARNINGS #include &lt;st...
汉诺塔c语言执行步骤详解,详解汉诺塔执行过程
weixin_30010599的博客
05-18 1453
问题补充：能否从以下开始详细像上面那样说明一下程序的运行过程吗?本人主要不知道函数的运行过程.返回B第一次调用6,向下执行,执行完毕,返回A第一次调用7,本次函数中p=a,q=b,r=c,m=3,向下执行,输出a->c,执行B,调用本身(B第一次调用),传入q,p,r(b,a,c),m=28,p=b,q=a,r=c,m=2,执行A,调用本身(A'第一次调用,注意是B函数调用中再次调用A) 传...
汉诺塔的移动函数
TOP
07-20 3549
汉诺塔的移动： 用Python编写move(n, a, b,c)函数，接收参数n，n表示3个柱子A、B、C中第1个柱子A的盘子数量，打印出把所有盘子从A借助B移动到C的方法； #期待输出: #A --> C #A --> B #C --> B #A --> C #B --> A #B --> C #A --> C move(3,'A', 'B', 'C')
C语言第七章-递归完整版资料.ppt
11-14
"C语言第七章-递归完整版资料.ppt" C语言的第七章主要聚焦于递归这一编程概念，这是程序设计中一个非常重要且基础的工具。递归是解决问题的一种策略，它通过调用自身来解决更小规模的相同问题，直到达到基本情况...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值