Ackerman函数

Ackerman函数的定义如下：
 akm(m,n) = n+1                   m = 0

          = akm(m-1,1)            m!=0,n = 0

          = akm(m-1,akm(m,n-1))   m!=0,n!=0

//递归方法求解

   public static int akmRecursion( int m, int n){
     if(m==0)
       return n+1;
     else if(n==0){
       return akmRecursion(m-1,1);
    }
     else{
       return akmRecursion(m-1,akmRecursion(m,n-1));
    }
  }

//使用栈的非递归求解

public static int akm0( int m, int n){
    Stack<AKM> s= new Stack<AKM>();   
    s.push( new AKM(m,n));//将值对(m,n)入栈
     while(!s.isEmpty()){
      AKM akm=s.pop();
      m=akm.getM();
      n=akm.getN();
       if(m ==0){
         if(s.isEmpty())
           return n +1;
        s.peek().setN(n +1); //将中间结果赋给栈顶值对中的n
      }
       else if(n ==0){
        s.push( new AKM(m-1,1));
      } else{
        s.push( new AKM(m-1,n));
        s.push( new AKM(m,n-1));
      }
    }   
     return -1;    
  }

观察可发现，其实只要m进栈即可

   public static int akm( int m, int n){
    Stack<Integer> s= new Stack<Integer>();
    
    s.push(m);
     while(!s.isEmpty()){
      m= s.pop().intValue();
       if(m ==0){
         if(s.isEmpty())
           return n +1;
        n=n+1;
      }
       else if(n ==0){
        s.push(m-1);
        n=1;
      } else{
        s.push(m-1);
        s.push(m);
        n=n-1;
      }
    }    
     return -1;   
  }

对Ackerman计算的复杂度分析？