从编译原理理解递归

最新推荐文章于 2022-09-16 11:21:07 发布
最新推荐文章于 2022-09-16 11:21:07 发布
阅读量1.9k 收藏 4
点赞数
分类专栏： 算法 数据结构 文章标签： 编译原理 斐波那契数列 算法 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a6129181/article/details/78868220
版权

递归
相关概念
1 栈结构
2 终止条件
3 编译原理
从最简单的例子入手
demo1

public class Fibonacci {
   public void A(int n) {
      if(n>0)
        {
        print("%d",n);
        A(n-1);
        }
   }

   public static void main(String[] args) {
       int x=3;
        A(x);
   }
}


输出结果是3 2 1
demo2
public class Fibonacci {
   public void A(int n) {
      if(n>0)
        {
            A(n-1);
            print("%d",n);
        }
   }

   public static void main(String[] args) {
       int x=3;
        A(x);
   }
}
输出结果是1 2 3 
重点在于理解编译器的栈运行模式
参考编译原理
demo1
heap











stack























  n=0






A(int n)  n=1 position  <-1
n=1position  <-1
n=1 position  <-1




  A(int n)  n=2 position  <-1
A(int n)  n=2position  <-1
n=2position  <-1
n=2position  <-1
n=2 position  <-1


  A(int n)  n=3   postion  <-1
A(int n)  n=3    position  <-1
A(int n)  n=3 position  <-1
n=3 position  <-1
n=3position  <-1
n=3position  <-1
n=3 position  <-1
console

3
 2
1




static variables








code
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        print("%d",n);
        A(n-1);
          }
   }

   public static void main(String[] args) <- 1 {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        print("%d",n);   
        A(n-1); <-1
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        print("%d",n);
        A(n-1); <-1
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        print("%d",n);
        A(n-1); <-1
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0) <-1
          {
        print("%d",n);
        A(n-1);
          }
   }<-2

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        print("%d",n);
        A(n-1); <-1
          }<-2
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        print("%d",n);
        A(n-1); <-1
          } <-2
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        print("%d",n);
        A(n-1); <-1
          }<-2
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
demo2
heap












stack

























  A(int n)  n=0position  <-1 要执行 };
n=0position  <-1






A(int n) n=1position  <-1 要执行 print("%d",n);
A(int n)  n=1position  <-1 要执行 print("%d",n);
A(int n)  n=1position  <-1 要执行 print("%d",n);
A(int n)    n=1position  <-1




A(int n)  n=2position  <-1 要执行 print("%d",n);
A(int n)  n=2position  <-1 要执行 print("%d",n);
A(int n)  n=2position  <-1 要执行 print("%d",n);
A(int n)  n=2position  <-1 要执行 print("%d",n);
A(int n)  n=2position  <-1 要执行 print("%d",n);
A(int n)    n=2position  <-1 要执行 print("%d",n);
A(int n)  n=2position  <-1 要执行 print("%d",n);

A(int n)  n=3   position  <-1 要执行print("%d",n);
A(int n)  n=3    position  <-1 要执行 print("%d",n);
A(int n)  n=3 position  <-1 要执行 print("%d",n);
A(int n)  n=3 position  <-1 要执行 print("%d",n);
A(int n)  n=3 position  <-1 要执行 print("%d",n);
A(int n)  n=3 position  <-1 要执行 print("%d",n);
A(int n)  n=3 position  <-1 要执行 print("%d",n);
A(int n)    n=3 position  <-1 要执行 print("%d",n);
console

 
 
 


1
2
3
static variables









code
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        A(n-1);
        print("%d",n);
          }
   }

   public static void main(String[] args) <- 1 {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) { <-2
      if(n>0)
          {
         A(n-1);<-1 
        print("%d",n);
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) { <-2
      if(n>0)
          {
         A(n-1);<-1
        print("%d",n);
        
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) { <-2
      if(n>0)
          {
         A(n-1);<-1
        print("%d",n);
        
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0) <-1
          {
         A(n-1);
        print("%d",n);
          }
   } <-2

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {    
        A(n-1);
        print("%d",n);
          }
   } <-1

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        A(n-1);
        print("%d",n); <-1
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        A(n-1);
        print("%d",n); <-1
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}
public class Fibonacci {
   public void A(int n) {
      if(n>0)
          {
        A(n-1);
        print("%d",n); <-1
          }
   }

   public static void main(String[] args) {
       int x=3;
         A(x);
   }
}

在举一个例子是 Fibonacci list
f(1)=1    f(0)=0
Demo
public class {
    // 使用递归方法
    private static int getFibo(int i) {
        if (i == 1 || i == 2)
            return 1;
        else
            return getFibo(i - 1) + getFibo(i - 2);
    }

    public static void main(String[] args) {
        System.out.println("斐波那契数列的前20项为：");
        for (int j = 1; j <= 20; j++) {
            System.out.print(getFibo(j) + "\t");
            if (j % 5 == 0)
                System.out.println();
        }
    }
}
费波纳切更能展现出编译原理中编译器的运行结构。

费波纳切运行结构非常恼火
但是通过费波纳切可以记得一个重要点是当进入栈的时候，函数的运行起点同时被保存
保存的要素有三个
函数A() n的值   函数运行位置
当返回后，函数从后面继续执行 
最重要一点
继续往后执行不意味着出栈，而是以前面保存的n值继续执行后面的
return getFibo(i - 1) + getFibo(i - 2);
例如此处  保存getFibo(i - 1) n=i-1 此处i=4 则getFibo(i - 1)执行为getFibo(3)
然后执行 n=i-1 后面的 getFibo(i - 2) 执行getFibo(i - 2) 执行为getFibo(2)


斐波那契数列排列后类似如下形式

引用

ping live
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编译原理 递归子程序方法 代码
02-14
1.定义部分：定义常量、变量、数据结构。 2.初始化：从文件将输入符号串输入到字符缓冲区中。 3.利用递归下降分析法分析，对每个非终结符编写函数，在主函数中调用文法开始符号的函数。
编译原理实验三 递归下降分析
05-10
递归下降分析实验报告 编译原理实验三 递归下降分析是基于编译原理的实验报告，旨在通过递归下降分析法对任意输入的符号串...该实验为我们提供了一个实践递归下降分析法的机会，提高了我们对编译原理的理解和掌握。
递归函数的原理
zifuttt的专栏
04-10 1万+
1.      函数定义：就是函数体的实现。函数体就是一个代码块，它在函数被调用时执行。 函数声明：向编译器提供该函数的相关的信息，包括：参数的数量，每个参数的类型以及返回值的类型。用于函数被正确的调用。 【注意】：当一个函数被调用时，编译器如果无法看到它的任何声明，那么它就假定函数返回一个整型值。对于那些返回值不是整型的函数，在调用之前对它们进行声明是非常重要的，这可以避免由于不可预测的类型
编译原理——递归程序基本思想和编程方法
TTTSEP9TH2244的博客
01-19 1729
一、实验目的: (1) 掌握递归程序基本思想和编程方法。 二、实验内容: 查阅资料了解递归思想和递归程序编写； 递归（recursion）：程序调用自身的编程技巧。 递归满足2个条件： 1）有反复执行的过程（调用自身） 2）有跳出反复执行过程的条件（递归出口） 调试、编译、自定义主程序，运行程序。 三、实验原理: 递归（recursion）就是子程序（或函数）直接调用自己或通过一系列调用语句间接调用自己，是一种描述问题和解决问题的基本方法。 递归通常用来解决结构自相似的问题。所谓结构自相似，是
关于编译原理 递归下将分析程序
iteye_18894的博客
05-01 146
编译原理实验要求构造一个地跪下将分析器，目标是能够对表达式进行自上而下语法分析，主要是识别i+i*i，我编的程序感觉是能实现分析，但不能判断是否符合语法 识别语法为： E->T|E+T T->F|T*F F->i|(E) 程序的源代码为： #include #include using namespace std; bool F(string &str,char* &i...
编译原理递归下降法
yangyangcome的博客
07-12 1008
p126例4.1 对于文法G[E] E::=E+T|T T::=T*F|F F::=(E)|i，在消去左递归以及回溯性之后的等价文法为： E::=TE’ E’::=+TE’|T::=FT′T′::=∗FT′|T::=FT′T′::=∗FT′| T::=FT' T'::=*FT'| F::=(E)|i（其中$代表空） #include&amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;g...
编译原理-递归下降分析
07-10
在编译原理中，递归下降分析是一种基于上下文无关文法（Context-Free Grammar, CFG）的解析技术，主要用于理解程序的语法结构。本实验旨在设计并实现一个递归下降分析程序，它能够接收词法分析程序提供的单词序列，...
编译原理-递归下降.zip
04-02
编译原理课程实验-递归下降分析子程序： 实验目的：掌握最基本的自顶向下分析方法，即递归下降子程序方法，理解其特点和适用范围（回溯，左递归等现象），锻炼递归调用程序的构造方法。 实现功能：给定表达式文法G...
编译原理-递归下降分析实验C++
最新发布
12-26
总的来说，递归下降分析是编译原理中的一个重要概念，它帮助我们理解如何将高级语言转化为机器可以理解的形式。通过C++实现递归下降分析，不仅可以加深对编译原理的理解，还能提升编程技能。在实际开发中，递归下降...
编译原理 递归下降语法分析程序（代码+说明文档）
07-10
此外，可能还会有对语法分析理论的简要介绍，帮助理解递归下降解析的背景和应用场景。 7. **实验二**：根据标签，这可能是课程或教材中的第二个实验，旨在加深学生对编译原理中递归下降分析的理解和应用能力。 ...
编译原理大作业（递归下降法）
12-31
编译原理大作业，C语言小子集编译程序-递归下降分析。本上机实习是为C语言(子集)设计一个编译程序，完成词法分析、语法分析、语义分析等功能，并生成某种机器上的目标代码(汇编语言)或中间代码(四元式)。
递归调用的子程序示例gdb调试用
06-19
递归调用的子程序示例gdb调试用，是一个很好的学习资料，有选择的进行了GDB的调度，是从很多好例子中挑出来的。
递归，预编译（上）
weixin_43706224的博客
05-24 210
1.递归的规律是先执行的最后被执行完， 2.嵌套的规则 3.预编译过程 4.这两个效果都来源于预编译 5. 6.预编译前奏 7.预编译的过程题目 上题的答案 8. GO的知识与imply 这个知识点一结合，便有了下面的题目 9.难一点的题目 10. ...
编译期递归的一个例子
Magicpang
03-08 557
from http://stackoverflow.com/questions/4568645/printing-1-to-1000-without-loop-or-conditionals #include template struct NumberGeneration{ static void out(std::ostream& os) { NumberGenerat
例解如何编写递归程序
麦哲思科技
03-02 929
递归是指方法在执行的过程中自己调用自己。用递归能解决的问题通常能将问题不断缩小为性质相同但规模更小的问题（递归情况），直到问题足够小能够直接解决（基本情况）。递归程序编写有4个要点：1问题是否可以递归描述？2递归结束的条件是什么？3递归调用之前做什么准备工作？4递归调用之后做什么收尾工作？ 以下通过一个稍微复杂的程序来举例说明一下如何编写递归程序。有一只中国象棋中的 “ 马 ” ，在半张棋盘的左下
【编译原理】-- 第二章（一）（文法和语言的定义、递归规则与递归文法、例题）
张修宇的博客
09-16 1829
枚举法--把该语言的所有句子列出放在一集合内（有限个句子时）有限条规则--描述语言的全部句子（有限或无限个句子），即文法表示。装置--检验和识别句子（有限或无限个句子），即自动机。元素的非空有穷集合，元素称符号。例：∑={0,1} ∑={a,b}ε是∑上的符号串若x是∑上的符号串，且a∈∑，则xa或ax是∑ 上的符号串，特别：ε x = x ε= x若y是∑上的符号串，当且仅当y可由以上两条产生。∑ ={b，c} ,求∑上的所有符号串根据1， ε是 ∑上的符号串。
2.3.5 递归规则与文法的递归性
qq_45180475的博客
08-04 4051
2.3.5 递归规则与文法的递归性 1. 递归规则 所谓递归规则,是指在规则的左部和右部具有相同非终结符的规则。 如果文法中有规则 A → A … 称为规则左递归。 如果文法中有规则 A → … A 称为规则右递归。 如果文法中有规则 A → … A … 称为规则递归。 2. 文法的递归性 文法的递归性是指对文法中任一非终结符,若能建立一个推导过程,在推导所得的符号串****中又出现了该非终结符本身,则文法是递归性的,否则是无递归性的。 若文法中有推导 A ⇒+ A … 称文法左递归。 若文法中有推导 A
【编译原理】递归下降语法分析设计原理与实现
somia的博客
07-20 4316
编译原理递归下降分析算法，有分析过程和完整代码。
编译原理（九）——递归下降法
热门推荐
很注重数学和408
09-24 1万+
背景： 自定向下的语法分析方法，LL(1)是一种非常直观的方法，它的分析过程是按照句子的定义来进行的，也就是说从开始符出发对要分析的串进行推导，如果推导成功就证明这个被分析的串是一个合法的句子，否则的话就有语法错误，但是在推导过程中，对文法进行了一些限定，保证推导过程是唯一的 。 总体上说，LL(1)就是在选择规则的时候加入了约束条件，考虑到输入流中的第一个符号，以及推导过程中的非终极符的规则选择，只有当头符属于当前Vn为左部的某条规则的Predict 集的时候，才使用该规则进行推导，否则即错。对规则的.
编译原理+消除左递归
10-22
编译原理是计算机科学中的一个重要分支，它研究如何将高级语言编写的程序转换成计算机能够理解和执行的机器语言程序。编译原理主要包括词法分析、语法分析、语义分析、中间代码生成、代码优化和目标代码生成等几个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值