递归简介

最新推荐文章于 2022-10-13 14:34:43 发布

hust_sheng

最新推荐文章于 2022-10-13 14:34:43 发布

阅读量573

点赞数

分类专栏： C语言不简单的小知识点文章标签：递归函数

本文链接：https://blog.csdn.net/hust_sheng/article/details/48224721

版权

C语言不简单的小知识点专栏收录该内容

23 篇文章 20 订阅

订阅专栏

关于递归

递归算法的设计思路

Recursive_SOLVE (P) //P是当前问题
if  P的规模足够小 then 直接求解
else
     将P转换为规模较小问题P'
     Recursive_SOLVE(P')  //递归调用
     将P'还原成为原问题P，结果合并
endif
END Recursive_SOLVE

递归的低效率
- 递归调用实际上是函数自己在调用自己，而函数的调用开销是很大的，系统要为每次函数调用分配存储空间，并将调用点压栈予以记录。而在函数调用结束后，还要释放空间，弹栈恢复断点。所以说，函数调用不仅浪费空间，还浪费时间。
- 递归计算的过程可能会造成重复计算。
低效率的解决方法
- 改进方法：保存中间结果（将递归转化为递推），如下：
  递归：递归是一种从上至下的“分解求解“的过程，即不断地把大问题分解为小问题，直到小问题规模足够小，然后求解并进行递归返回和结果合并。——效率差！
  递推：递推是一种从下往上的“合并求解“过程，即从解决小问题出发，记录小问题的答案，并根据已有的小问题的答案，把问题往大里扩展，“滚雪球”，直到达到大问题的规模为止。并通常用迭代（循环）的方式实现，而不是递归调用，一般认为效率上比递归好。
- 递推算法的设计思想
  将递归转化为递推，需要解决如下几个问题：
  1.如何体现递归反映出来的、通过调用自身实现的重复计算——从程序入口重复执行本程序的代码的过程？
  2.每次递归完成后要接着递归点往下继续执行，递推时如何记录重复执行点，以实现与递归类似的、在重复点重复执行、执行完后又能接着重复点之后的代码继续执行？
  3.如果递归函数有返回值，返回值需要返回至递归调用点，用迭代实现时，如何处理返回值？（小问题的解数组ans）
```
Recurrence_SOLVE(P)   //P是当前问题
定义数组ans[P]  //定义一个与问题规模P相适应的数组，用于存放答案
for i from 边界问题P0 to P do    //从小问题求解做起
  if i是边界值 then 直接求解，将结果保存在ans中
  else
    将i转换为规模较小问题i'
    ans[i] ←build answer by ans[i']
    //用已得到的答案构造i的解ans[i]
  endif
repeat
END Recurrence_SOLVE
```
递归式及其求解
- 递归式
  递归式是一组等式或不等式，它所描述的函数是用在更小的输入下该函数的值来定义的。
  如：归并排序（MERGESORT）的运行时间T(n)表示如下：
  - 顺便说一下递推式（类似于我们平常说的数列）
    通过给出数列的第1项（或前若干项），并给出数列的某一项与它的前一项（或前若干项）的关系式来表示数列，这种表示数列的式子叫做这个数列的递推公式。
    1.斐波纳契数列的递推公式为fn=fn-1+fn-2
    2.等差数列递推公式：an=an-1+d
    3.等比数列递推公式：bn=bn-1×q
- 递推式与递归式之间的联系
  当递推式中只含数列中的项，而无常数项或其它项时，就叫做递归公式。
- 递归式的求解
  求解递归式就是化简递归式，以得到形式简单的函数表示。三种常用方法：
  1.代换法
  2.递归树法
  3.主方法

关于二叉树的几个递归操作

//搜索
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>  

using namespace std;

typedef int ElementType; // 类型的重命名

typedef struct TreeNode *Position;
typedef struct TreeNode *Tree;
struct TreeNode
{
    ElementType Element;
    Tree Left;
    Tree Right;
};  // struct需要分号


char str[101] = "abc##de#g##f###";
int count_temp = 0;

/* 创建二叉树 
* 使用双指针的原因：
* 指针本身也是变量的一种，在（单指针）参数的传递中，也是使用传值的方式，
* 也就是说函数只能改变指针指向的内容，无法修改指针的内容。
* 但是，在二叉树中涉及到对节点的递归重建（递归遍历也是一样，都改变了指针的指向），此时就要改变指针的内容来实现对各节点的操作，
* 这就要借助于指针的指针，即使用二重指针，这本来就是一个难点，仔细体会下！
*/

void createBtree(Tree *T)
{
    if (str[count_temp++] == '#')
    {
        *T = NULL;
    }
    else 
    {
        *T = (Tree )malloc(sizeof(TreeNode));
        (*T)->Element = str[count_temp - 1];
        createBtree(&(*T)->Left);
        createBtree(&(*T)->Right);
    }
}


/*
* 1. 如果二叉树为空，而返回0
* 2. 如果二叉树不为空，二叉树节点树=左子树节点个数+右子树节点个数+1 
*/
int GetNodeNum(Tree T)
{
    if( T == NULL)//递归出口
    {
        return 0;
    }
    return GetNodeNum(T->Left) + GetNodeNum(T->Right) + 1;
}

/*
* 1. 如果二叉树为空，二叉树的深度为0
* 2. 如果二叉树不为空，二叉树的深度 = max(左子树深度，右子树深度）+ 1；
*/
int GetDepth(Tree T)
{
    if( T == NULL)//
    {
    return 0;
    }
    int LeftDepth = GetDepth(T->Left);
    int RightDepth = GetDepth(T->Right);
    return LeftDepth > RightDepth ? (LeftDepth+1) : (RightDepth+1);
}

//先序遍历二叉树
void preOrder(Tree T)
{
    if( T != NULL)
    {
    printf("%c ",T->Element);
    preOrder(T->Left);
    preOrder(T->Right);
    }
}

//中序遍历二叉树
void inOrder(Tree T)
{
    if( T != NULL)
    {
    inOrder(T->Left);
    printf("%c ",T->Element);
    inOrder(T->Right);
    }
}
//后续遍历二叉树
void postOrder(Tree T)
{
    if( T != NULL)
    {
    postOrder(T->Left);
    postOrder(T->Right);
    printf("%c ",T->Element);
    }
}

/*  
* 1. 如果二叉树为空，或者k<1返回0
* 2. 如果二叉树不为空并且k==1,返回1；
* 3. 如果二叉树不为空且k>1，返回左子树中k-1层的节点个数与右子树k-1层节点个数之和。
*/
int GetNodeNumKthLevel(Tree T, int k)
{
    if( T==NULL || k<1)
        return 0;
    if( k == 1)
        return 1;
    int numLeft = GetNodeNumKthLevel(T->Left, k-1);
    int numRight= GetNodeNumKthLevel(T->Right,k-1);
    return (numLeft + numRight);
}

/*  
* 1. 如果二叉树为空，或者k<1返回0
* 2. 如果二叉树不为空且左右子树为空，返回1
* 3. 如果二叉树不为空且左右子树不为空，返回左子树叶子节点个数加上右子树叶子节点个数。
*/
int GetLeafNodeNum( Tree T)
{
    if( T == NULL )
        return 0;
    if( T->Left == NULL && T->Right == NULL)
        return 1;
    int numLeft = GetLeafNodeNum( T->Left);
    int numRight = GetLeafNodeNum(T->Right);
    return (numLeft + numRight);
}

/*
* 1. 如果两棵二叉树都为空，返回真
* 2. 如果两棵二叉树为空，另一棵不为空，返回假
* 3. 如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假
*/
bool StructureCmp(Tree T1, Tree T2)
{
    if( T1 == NULL && T2 == NULL)//都为空
        return true;
    else
    if( T1 == NULL || T2 == NULL)//一个空，一个非空
        return false;

    bool left = StructureCmp(T1->Left, T2->Left);
    bool right =StructureCmp(T2->Right,T2->Right);
    return (left&right);
}

/*
* 1. 如果二叉树为空，返回真
* 2. 如果二叉树非空，如果左右子树都是AVL树并且左右子树高度相差不大于1，返回真，其他返回假。
*/
bool IsAVL(Tree T, int* height)
{
    if(T == NULL )
    {    
        height = 0;
        return true;
    }

    int heightLeft,heightRight;
    bool left = IsAVL(T->Left, &heightLeft);
    bool right =IsAVL(T->Right,&heightRight);
    if( left && right && abs(heightLeft-heightRight)<=1)
    {
        *height = max(heightLeft, heightRight) + 1;
        return true;
    }
    else
    {
        *height = max( heightLeft, heightRight) + 1;
        return false;
    }
}

/*
* 将当前二叉树转化为其镜像二叉树
*/
Tree Mirror(Tree T)
{
    if( T == NULL )
        return 0;
    if( T->Left == NULL && T->Right == NULL)
        return 0;

    Position temp = T->Right;
    T->Right = T->Left;
    T->Left = temp;
    Mirror(T->Left);
    Mirror(T->Right);
}

/* 
* 如果二叉树为空，返回0，即同时记录左子树和右子树的深度——0；
* 如果二叉树不为空，最大距离要么是左子树中的最大距离，要么是右子树的最大距离，
* 要么是 左子树节点到根节点的最大距离+右子树节点中到根节点的最大距离，同时记录左右子树节点中到 根节点的最大距离。
*/
int GetMaxDistance(Tree T, int *maxLeft, int *maxRight)
{
    // maxLeft：左子树中节点距离根节点最远距离
    // maxRight：右子树中节点距离根节点最远距离
    if( T == NULL)
    {
        maxLeft = 0;
        maxRight = 0;
        return 0;
    }
    int maxLL, maxLR, maxRL, maxRR;
    int maxDistLeft, maxDistRight;
    if( T->Left != NULL)
    {
        maxDistLeft = GetMaxDistance(T->Left, &maxLL, &maxLR);
        *maxLeft = max(maxLL, maxLR) + 1;
    }
    else
    {
        maxDistLeft = 0;
        *maxLeft = 0;
    }
    if( T->Right != NULL)
    {
        maxDistRight = GetMaxDistance( T->Right, &maxRL, &maxRR);
        *maxRight = max( maxRL, maxRR) + 1;
    }
    else
    {
        maxDistRight = 0;
        *maxRight = 0;
    }

    return max( max(maxDistLeft, maxDistRight), *maxLeft+*maxRight);
}

int main()
{
    Tree T;
    int temp;

    /* 创建二叉树 */
    createBtree(&T);  // 参数是**TreeNode

    /* 求解二叉树中的节点个数 */
    temp = GetNodeNum(T);
    printf("二叉树的节点个数：%d\n", temp);

    /* 求解二叉树的深度 */
    temp = GetDepth(T);
    printf("二叉树的深度：%d\n", temp);

    /* 遍历 */
    printf("前序遍历（递归）：");
    preOrder(T);
    printf("\n");
    printf("中序遍历（递归）：");
    inOrder(T);
    printf("\n");
    printf("后序遍历（递归）：");
    postOrder(T);
    printf("\n");

    // 求二叉树第k层节点的个数
    temp = GetNodeNumKthLevel(T, 2);
    printf("二叉树第k层节点的个数：%d\n", temp);

    // 求二叉树中叶子节点的个数
    temp = GetLeafNodeNum(T);
    printf("二叉树中叶子节点的个数：%d\n", temp);

    // 判断二叉树结构是否相同相
    strcpy(str, "abc##de#g##f###");
    count_temp = 0;
    Tree T0;
    createBtree(&T0);
    if(StructureCmp(T, T0))
    {
        printf("两个二叉树的结构相同\n");
    }
    else
    {
        printf("两个二叉树的结构不同\n");
    }

    // 判断二叉树是不是平衡二叉树
    int height;
    if(IsAVL(T, &height))
    {
        printf("该二叉树是平衡二叉树\n");
    }
    else
    {
        printf("该二叉树不是平衡二叉树\n");
    }

    // 求二叉树的镜像二叉树
    Mirror(T);
    printf("镜像二叉树的后序遍历（递归）：");
    postOrder(T);
    printf("\n");

    // 求二叉树中节点的最大距离（二叉树中相距最远的两个节点）
    int maxleft, maxright;
    temp = GetMaxDistance(T, &maxleft, &maxright);
    printf("二叉树中节点距离最大为：%d", temp);


    system("pause");
    return 0;
}