Fatal编程技术网
  • recursion/
  • Recursion 有相互递归的例子吗？

Recursion 有相互递归的例子吗？

recursion

Recursion 有相互递归的例子吗？,recursion,Recursion,有没有一个递归函数调用另一个也调用第一个函数的例子 例如： function1() { //do something function2(); //do something } function2() { //do something function1(); //do something } 这有点做作，效率也不是很高，但你可以用一个函数来计算斐波那契数，如下所示： fib2(n) { return fib(n-2); } f

有没有一个递归函数调用另一个也调用第一个函数的例子

例如：

function1()
{    
    //do something 
    function2();
    //do something
}

function2()
{
    //do something 
    function1();
    //do something
}
这有点做作，效率也不是很高，但你可以用一个函数来计算斐波那契数，如下所示：


fib2(n) { return fib(n-2); }

fib1(n) { return fib(n-1); }

fib(n)
{
  if (n>1)
    return fib1(n) + fib2(n);
  else
    return 1;
}
在这种情况下，如果语言支持

的话，它的效率可以大大提高。正确的术语是相互递归

该页面上有一个示例，我将在这里用Java重现：

boolean even( int number )
{    
    if( number == 0 )
        return true;
    else
        return odd(abs(number)-1)
}

boolean odd( int number )
{
    if( number == 0 )
        return false;
    else
        return even(abs(number)-1);
}
其中abs（n）表示返回一个数字的绝对值

显然，这并不高效，只是为了说明一点。

一个例子可能是在国际象棋等游戏程序中常用的最小-最大算法。从游戏树的顶部开始，目标是找到以下级别所有节点的最大值，其值定义为该级别以下节点值的最小值，其值定义为该级别以下节点值的最大值，在具有适当尾部调用的语言中，相互尾部递归是实现自动机的一种非常自然的方式。

相互递归在解析数学表达式（和其他语法）的代码中很常见。基于以下语法的递归下降解析器自然会包含相互递归：
表达式术语术语因子主表达式

expression
    + terms
    - terms
    terms

terms
    term + terms
    term - terms

term
    factor
    factor * term
    factor / term

factor
    primary
    primary ^ factor

primary
    ( expression )
    number
    name
    name ( expression )
我可以想到两种常见的相互递归源

处理相互递归类型的函数 考虑一个抽象语法树（AST），它在每个节点中保存位置信息。类型可能如下所示：

type Expr=
|整数的整数
|字符串变量
|添加ExprAux*ExprAux
ExprAux=int*Expr的Expr
编写操作这些类型的值的函数的最简单方法是编写相互递归的函数。例如，用于查找自由变量集的函数：

让rec freevalues=函数
|Int n->Set.empty
|变量x->Set.singleton x
|添加（f，g）->Set.union（freeVariablesAux f）（freeVariablesAux g）
和freeVariablesAux（Expr（loc，e））=
自由变量
状态机 考虑一个打开、关闭或暂停的状态机，其中包含启动、停止、暂停和恢复指令（F代码）：

type指令=开始|停止|暂停|恢复
状态机可以编写为相互递归的函数，每个状态对应一个函数：

type State=状态（指令->状态）
设rec isOff=函数
|开始->状态
|_uf->State isOff
和=函数
|停止->状态isOff
|暂停->状态暂停
|州政府
和isPaused=函数
|停止->状态isOff
|恢复->状态更新
|_uu->State isPaused
这是我的编码解决方案。对于使用相互递归执行
*
，
/
，
-
操作的计算器应用程序。它还检查括号（
（）
）以确定优先顺序

Flow:: expression -> term -> factor -> expression 

    Calculator.h
    #ifndef CALCULATOR_H_
    #define CALCULATOR_H_

    #include <string>
    using namespace std;

    /****** A Calculator Class holding expression, term, factor ********/
    class Calculator
    {
    public:
        /**Default Constructor*/
        Calculator();

        /** Parameterized Constructor common for all exception
         * @aparam e exception value
         * */
        Calculator(char e);

        /**
         * Function to start computation
         * @param input - input expression*/
        void start(string input);

        /**
         * Evaluates Term*
         * @param input string for term*/
        double term(string& input);

         /* Evaluates factor*
         * @param input string for factor*/
        double factor(string& input);

         /* Evaluates Expression*
          * @param input string for expression*/
        double expression(string& input);


         /* Evaluates number*
          * @param input string for number*/
        string number(string n);

        /**
         * Prints calculates value of the expression
         * */
        void print();

        /**
         * Converts char to double
         * @param c input char
         * */
        double charTONum(const char* c);

        /**
         * Get error
         */
        char get_value() const;
        /** Reset all values*/
        void reset();
    private:
        int lock;//set lock to check extra parenthesis
        double result;// result
        char error_msg;// error message
    };

    /**Error for unexpected string operation*/
    class Unexpected_error:public Calculator
    {
    public:
        Unexpected_error(char e):Calculator(e){};
    };

    /**Error for missing parenthesis*/
    class Missing_parenthesis:public Calculator
    {
    public:
        Missing_parenthesis(char e):Calculator(e){};
    };

    /**Error if divide by zeros*/
    class DivideByZero:public Calculator{
    public:
        DivideByZero():Calculator(){};
    };
    #endif
    ===============================================================================

    Calculator.cpp

    //============================================================================
    // Name        : Calculator.cpp
    // Author      : Anurag
    // Version     :
    // Copyright   : Your copyright notice
    // Description : Calculator using mutual recursion in C++, Ansi-style
    //============================================================================

    #include "Calculator.h"
    #include <iostream>
    #include <string>
    #include <math.h>
    #include <exception>
    using namespace std;


    Calculator::Calculator():lock(0),result(0),error_msg(' '){

    }

    Calculator::Calculator(char e):result(0), error_msg(e) {

    }

    char Calculator::get_value() const {
        return this->error_msg;
    }

    void Calculator::start(string input) {
        try{
        result = expression(input);
        print();
        }catch (Unexpected_error e) {
            cout<<result<<endl;
            cout<<"***** Unexpected "<<e.get_value()<<endl;
        }catch (Missing_parenthesis e) {
            cout<<"***** Missing "<<e.get_value()<<endl;
        }catch (DivideByZero e) {
            cout<<"***** Division By Zero" << endl;
        }
    }

    double Calculator::expression(string& input) {
        double expression=0;
        if(input.size()==0)
            return 0;
        expression = term(input);
        if(input[0] == ' ')
            input = input.substr(1);
        if(input[0] == '+') {
            input = input.substr(1);
            expression += term(input);
        }
        else if(input[0] == '-') {
            input = input.substr(1);
            expression -= term(input);
        }
        if(input[0] == '%'){
            result = expression;
            throw Unexpected_error(input[0]);
        }
        if(input[0]==')' && lock<=0 )
            throw Missing_parenthesis(')');
        return expression;
    }

    double Calculator::term(string& input) {
        if(input.size()==0)
            return 1;
        double term=1;
        term = factor(input);
        if(input[0] == ' ')
            input = input.substr(1);
        if(input[0] == '*') {
            input = input.substr(1);
            term = term * factor(input);
        }
        else if(input[0] == '/') {
            input = input.substr(1);
            double den = factor(input);
            if(den==0) {
                throw DivideByZero();
            }
            term = term / den;
        }
        return term;
    }

    double Calculator::factor(string& input) {
        double factor=0;
        if(input[0] == ' ') {
            input = input.substr(1);
        }
        if(input[0] == '(') {
            lock++;
            input = input.substr(1);
            factor = expression(input);
            if(input[0]==')') {
                lock--;
                input = input.substr(1);
                return factor;
            }else{
                throw Missing_parenthesis(')');
            }
        }
        else if (input[0]>='0' && input[0]<='9'){
            string nums = input.substr(0,1) + number(input.substr(1));
            input = input.substr(nums.size());
            return stod(nums);
        }
        else {
            result = factor;
            throw Unexpected_error(input[0]);
        }
        return factor;
    }

    string Calculator::number(string input) {
        if(input.substr(0,2)=="E+" || input.substr(0,2)=="E-" || input.substr(0,2)=="e-" || input.substr(0,2)=="e-")
            return input.substr(0,2) + number(input.substr(2));
        else if((input[0]>='0' && input[0]<='9') || (input[0]=='.'))
            return input.substr(0,1) + number(input.substr(1));
        else
            return "";
    }

    void Calculator::print() {
        cout << result << endl;
    }

    void Calculator::reset(){
        this->lock=0;
        this->result=0;
    }
    int main() {

        Calculator* cal = new Calculator;
        string input;
        cout<<"Expression? ";
        getline(cin,input);
        while(input!="."){
            cal->start(input.substr(0,input.size()-2));
            cout<<"Expression? ";
            cal->reset();
            getline(cin,input);
        }
        cout << "Done!" << endl;
        return 0;
    }
    ==============================================================
    Sample input-> Expression? (42+8)*10 =
    Output-> 500

Flow:：expression->term->factor->expression
计算器.h
#ifndef计算器_
#定义计算器_
#包括
使用名称空间std；
/******包含表达式、术语、因子的计算器类********/
类计算器
{
公众：
/**默认构造函数*/
计算器（）；
/**参数化构造函数，适用于所有异常
*@aparame异常值
* */
计算器（chare）；
/**
*函数启动计算
*@param输入-输入表达式*/
无效开始（字符串输入）；
/**
*评估术语*
*@param术语的输入字符串*/
双项（字符串和输入）；
/*评价因子*
*@param因子的输入字符串*/
双因素（字符串和输入）；
/*计算表达式*
*表达式的@param输入字符串*/
双表达式（字符串和输入）；
/*评估数字*
*@param数字输入字符串*/
字符串编号（字符串n）；
/**
*打印计算表达式的值
* */
作废打印（）；
/**
*将字符转换为双字符
*@param c输入字符
* */
双字符（常量字符*c）；
/**
*出错
*/
char get_value（）常量；
/**重置所有值*/
无效重置（）；
私人：
int lock；//设置lock以检查附加括号
双重结果；//结果
char error_msg；//错误消息
};
/**意外的字符串操作出错*/
类意外错误：公共计算器
{
公众：
意外错误（字符e）：计算器（e）{}；
};
/**缺少括号时出错*/
类缺少括号：公共计算器
{
公众：
缺少括号（字符e）：计算器（e）{}；
};
/**被零除时出错*/
类除以零：公共计算器{
公众：
除法为零（）：计算器（）{}；
};
#恩迪夫
===============================================================================
计算器
//============================================================================
//名称：Calculator.cpp
//作者：Anurag
//版本：
//版权：您的版权声明
//描述：使用C++中的相互递归的ANSI样式的计算器
//============================================================================
#包括“Calculator.h”
#包括
#包括
#包括
#包括
使用名称空间std；
计算器：：计算器（）：锁（0），结果（0），错误消息（“”）{
}
计算器：：计算器（字符e）：结果（0），错误消息（e）{
}
字符计算器：：get_value（）常量{
返回此->错误消息；
}
无效计算器：：开始（字符串输入）{
试一试{
结果=表达式