栈实现的递归函数-有限状态机

发现递归函数用栈实现和有限状态机大有关系，递归的过程可以用一个状态值控制，这样栈的压入，弹出每一步用一个状态值表示，逻辑就很清晰了。

 

 

 

 

现举例说明：

 

--.斐波拉契数列

 

数列的递归定义

 

f(1)=1

f(2)=1

f(n)=f(n-1)+f(n-2),其中n>=2

{f(n)}即为斐波拉契数列。

 

递归函数版本：

int FeiBo(int n)
{
 //state=0;
 if (n<=2)
 {
  //state=1;
  return 1;
 }
 else
 {
  //state=2;
  int m1=FeiBo(n-1);

  //state=3;
  int m2=FeiBo(n-2);

  //state=4;
  return m1+m2;
 }
}

 

栈实现的版本：

struct Param_F//栈元素定义
{
 int n;//参数
 int m1;//中间参数m1
 int m2;//中间参数m2
 int r;//函数返回值
 int s;//表示函数状态的值
 
 Param_F(int x,int y,int y1,int z,int w)//构造函数
 {
  n=x;
  m1=y;
  m2=y1;
  r=z;
  s=w;
 }
};

 

 

int FeiBo_N(int n)//基于栈的函数实现

{
 std::stack<Param_F> stack_p;
 
 stack_p.push(Param_F(n,0,0,0,0));
 
 Param_F p_c=stack_p.top();
 
 Param_F p_u=stack_p.top();
 
 while (!stack_p.empty())
 {
  switch(p_c.s)
  {
  case 0:
   {
    if (p_c.n<=2)
    {
     p_c.s=1;//状态变化
    }
    else
    {
     p_c.s=2;//状态变化

    }
   }
   break;
  case 1:
   {
    p_c.r=1;
    p_u=p_c;

    if (!stack_p.empty())
    {
     p_c=stack_p.top();
     stack_p.pop();
     int cs=p_c.s;
     if (cs==2)
     {
      p_c.m1=p_u.r;
      p_c.s=3;;//状态变化
     }
     else if (cs==3)
     {
      p_c.m2=p_u.r;
      p_c.s=4;;//状态变化
     }
    }

   }
   break;
  case 2:
   {
    stack_p.push(p_c);
    p_c.n=p_c.n-1;
    p_c.s=0;;//状态变化
    p_c.r=0;
   }
   break;
  case 3:
   {
    stack_p.push(p_c);
    p_c.n=p_c.n-2;
    p_c.s=0;;//状态变化
    p_c.r=0;
   }
   break;
  case 4:
   {
    p_c.r=p_c.m1+p_c.m2;
    p_u=p_c;
    
    if (!stack_p.empty())
    {
     p_c=stack_p.top();
     stack_p.pop();
     int cs=p_c.s;
     if (cs==2)
     {
      p_c.m1=p_u.r;
      p_c.s=3;;//状态变化
     }
     else if (cs==3)
     {
      p_c.m2=p_u.r;
      p_c.s=4;;//状态变化
     }
    }
    
   }
   break;
  }
 }

 return p_u.r;
}