nullITeye - 威尼斯人

nullITeye

2019年03月04日08时37分27秒 | 作者: 沛白 | 标签: | 浏览: 1964

在惯例表达式求值中:

输入为四则运算表达式,仅由数字、+、-、*、/ 、(、) 组成,没有空格,要求求其值.

咱们知道有运算等级,从左至右,括号里边的先运算,其次是* 、/,再是+、- ;

这样咱们就可以用递归来表达这个式子了:

1.                         

 2.

          

 3.          

 

     这样就可以用递归来描绘了

1. 

/**
求一个因子的值
double factor_value(){
 double result = 0 ;
 char c = cin.peek();//从cin看一个字符,不取出
 if(c(){
 cin.get();
 result = expression_value() ;
 cin.get();
 else{
 while(isdigit(c))//查看参数c是否为阿拉伯数字0到9
 result = 10*result + c - 0 ;
 cin.get() ;
 c = cin.peek();
 return result ;
}

 

/**
求一个项的值
double term_value()
 double result = factor_value() ;//求第一个因子的值
 bool more = true ;
 while(more){
 char op = cin.peek() ;
 if(op*||op/){
 cin.get() ;
 int value = factor_value() ;
 if(op  *) result*= value ;
 else result /= value ;
 else more = false ;
 return result ;
}
/**
求一个表达式的值
double expression_value(){
 double result = term_value() ;//求第一项的值
 bool more = true ;
 while(more){
 char op = cin.peek() ;
 if(op+||op-){
 cin.get() ;
 int value = term_value() ;
 if(op  +) result+= value ;
 else result -= value ;
 else more = false ;
 return result ;

4.

#include iostream 
using namespace std ;
double factor_value();//因子
double term_value();//项
double expression_value();//表达式
int main()
cout expression_value() endl;
 return 0 ;
}

    总结下递归的优缺陷:

    长处:直接、简捷、算法程序结构明晰、思路明晰。

    缺陷:递归的履行进程很让人头疼。

 

下面咱们就用栈来代替上面的递归程序:

 首要了解栈的概念:栈是一种运用规模广泛的数据结构,适用于各种具有“后进先出”特性的问题。

 

 栈与进程调用:

  1.考虑下面三个进程:

     public void A1(){

     begin :

      ........    

      r: b();

     .........

      endl ;

     }

     public void A2(){

       begin :

      ........    

      t: c();

     .........

      endl ;

      }

      public void A3(){

           begin :

            ........    

           endl ;

      }

进程A1在其进程体的某一处调用进程A2,A2以在其进程体的某一处调用进程A3,A3不调用其他进程。

当进程A1履行到的r处时,它自己实际上被"挂起来,而被调用进程A2开端运转。一向比及A2履行完毕这后才回来进程A1的r1处持续履行A1剩余部分。 在进程A2的上述运转中,因为调用了A3,A2同样在t处"挂"起并一向比及A3履行完毕后回来t1处才干持续履行后继句子。

     

 2.嵌套调用进程中调用联系

        

 3.相应工作栈的改变

    遇到一个进程调用便马上将相应的回来方位(及其它有用的信息)进栈;每逢一被调用进程履行完毕时,工作栈栈顶元素下好是此进程的回来方位。

 就以上面的惯例表达式为例:

        例: 1+(3-2)*4/2  

过程       OPTR栈       OPND栈      输入字符      首要操作
 1           #                          1          PUSH(OPND,1)
 2           #             1            +          PUSH(OPTR,+)
 3           #+            1            (          PUSH(OPTR,()
 4           #+(           1            3          PUSH(OPND,3)
 5           #+(           13           -          PUSH(OPTR,-)
 6           #+(-          13           2          PUSH(OPND,2)
 7           #+(-          132          )          operate(3,-,2)
 8           #+(           11                      POP(OPTR){消去一对括号}
 9           #+            11           *          PUSH(OPTR,*)
 10          #+*           11           4          PUSH(OPND,4)
 11          #+*           114          /          operate(1,*,4)
 12          #+            14                      PUSH(OPTR,/)
 12          #+/           14           2          PUSH(OPND,2)
 13          #+/           142          #          PUSH(OPND,#)       
 14          #+/           142                     operate(4,/,2)
 15          #+            12                      operate(1,+,2)
 16          #               3                       return(GetTop(OPND)); 

 

4.为什么要学习递归与非递归的转化办法:

并不是每一门言语都支撑递归的
有助于了解递归的实质
有助于了解栈,树等数据结构
一般来说,递归时刻杂乱度和对应的非递归差不多,可是递归的功率是适当低,它首要花费在重复的进栈出栈,各种中止等机制上,更有甚者,在递归求解进程中,某些解会重复的求好几回。

 

5.递归与非递归转化的原理
简略递归一般就是依据递归式来找出递推公式,即引进循环、递归调用树来模仿递归
杂乱递归一般就是模仿体系处理递归的机制,运用栈或行列等数据结构保存回溯点来求解。

 

举个比如:在快速排序中,就可以明晰的了解其间的道理。

 我仍是用Java还举这个比如吧,不必G++了

 1.用递归完成快速排序

 

package dsa;
 * 快速排序
 * @author tanlvxu
public class Demo21 {
 * @param args
 public static void main(String[] args) {
 int a[]={4,3,2,5} ;
 new Demo21().qSort_Init(a, 0, 3) ;
 for(int i=0;i i++)
 System.out.print(a[i]) ;
 public void swap(int a[],int low,int high)
 int temp = a[low] ;
 a[low] = a[high] ;
 a[high] = temp ;
 public int qSort(int a[],int low,int high)
 int p = a[low] ;
 while(low high)
 while(low high a[high] =p)
 high ;
 swap(a,low,high) ;
 while(low high a[high] =p)
 low++ ;
 swap(a,low,high) ;
 return low ;
 public void qSort_Init(int a[],int low,int high)
 int p ;
 if(low high)
 p = qSort(a,low,high);
 qSort_Init(a,low,p-1);
 qSort_Init(a,p+1,high);

 2.用栈完成快速排序

 

package dsa;
 * 用栈完成快速排序
 * @author tanlvxu
public class Demo22 {
 * @param args
 public static void main(String[] args) {
 // TODO Auto-generated method stub
 int a[]={4,3,2,5} ;
 new Demo22().qSort_Init(a, 0, 3) ;
 for(int i=0;i i++)
 System.out.print(a[i]) ;
 public void swap(int a[],int low,int high)
 int temp = a[low] ;
 a[low] = a[high] ;
 a[high] = temp ;
 public int qSort(int a[],int low,int high)
 int p = a[low] ;
 while(low high)
 while(low high a[high] =p)
 high ;
 swap(a,low,high) ;
 while(low high a[high] =p)
 low++ ;
 swap(a,low,high) ;
 return low ;
 public void qSort_Init(int a[],int low,int high)
 int m[] = new int[100] ;
 int n[] = new int[100] ;
 int cp,p,sublow,subhigh ;
 * 初始化栈和栈顶指针
 m[0] = low ;
 n[0] = high ;
 cp = 0 ;
 while(cp =0){
 sublow = m[cp] ;
 subhigh = n[cp] ;
 cp  ;
 if(sublow subhigh){
 p = qSort(a, sublow, subhigh) ;
 cp ++ ;
 m[cp] = sublow ;
 n[cp] = p-1 ;
 cp++ ;
 m[cp] = p + 1;
 n[cp] = subhigh;                          
			
版权声明
本文来源于网络,版权归原作者所有,其内容与观点不代表威尼斯人立场。转载文章仅为传播更有价值的信息,如采编人员采编有误或者版权原因,请与我们联系,我们核实后立即修改或删除。

猜您喜欢的文章