数据结构与算法（JAVA篇）之递归算法（四）

/**
 *
 * @author SunnyMoon
 */
//
/**
 * 概念介绍：
 * 
 * 消除递归：
 * 一个算法作为一个递归的方法通常从概念上很容易理解，但实际使用中递归的效率不高，在这种
 * 情况下，把递归算法转换成非递归的算法是非常有用的，这种转换经常用到栈。
 * 
 * 递归和栈：
 * 递归和栈之间有着紧密的联系，大部分的编译器使用栈实现递归的。
 * 
 * 调用方法的时候发生什么：
 * 1. 编译器会把这个方法所有当前参数及返回地址压入栈中；
 * 2. 将控制权交给这个方法，方法通过获得栈顶元素值访问参数；
 * 3. 方法运行结束的时候，值退栈，参数消失且控制权重新回到返回地址；
 * 
 * 模拟递归方法：
 * 可以将任意一个递归方法转换为非递归的基于栈的方法。在一些简单的情况可以完全消除栈，只
 * 使用一个简单的循环，但是在很复杂的情况，算法中必须须要保留栈。本例子是简单的情况，可
 * 以进一步完全消除栈。
 */
/
 /**
  * 计算三角数字的问题:
  * 递归算法描述如下
  * int triiangle(int n){
  *      if(n==1)
  *          return 1;
  *      else
  *          return (n+triangle(n-1));
  * }
  */
import java.io.*;
/**
 * 模拟一个递归方法，通用的方式消除递归
 */
class Params {//封装了方法的返回地址和方法的参数

    public int number;
    public int returnAddress;

    public Params(int num, int returnAdd) {
        number = num;
        returnAddress = returnAdd;
    }
}

class StackX {//模拟递归时使用的栈

    private int maxSize;
    private Params[] stackArray;
    private int top;

    public StackX(int s) {
        maxSize = s;
        stackArray = new Params[maxSize];
        top = -1;
    }

    public void push(Params p) {
        stackArray[++top] = p;
    }

    public Params pop() {
        return stackArray[top--];
    }

    public Params peek() {
        return stackArray[top];
    }
}

class StackTriangleApp {

    static int theNumber;
    static int theAnswer;
    static StackX theStack;
    static int logicAddress;
    static Params theseParams;

    public static void main(String[] args) throws IOException{//主方法
        System.out.print("Number = ");
        theNumber = getInt();
        stackTriangle();
        System.out.println("");
        System.out.println("Trriangle = " + theAnswer);
    }

    @SuppressWarnings("empty-statement")
    public static void stackTriangle() {//计算三角数字的方法，模拟递归方法
        theStack = new StackX(100);
        logicAddress = 1;//设置一个逻辑地址为入口地址
        while (step() == false);
    }

    public static boolean step() {
        switch (logicAddress) {
            case 1:
                theseParams = new Params(theNumber, 6);//设定循环返回的地址
                theStack.push(theseParams);
                logicAddress = 2;
                break;
            case 2:
                theseParams = theStack.peek();
                if (theseParams.number == 1) {
                    theAnswer = 1;
                    logicAddress = 5;
                } else {
                    logicAddress = 3;
                }
                break;
            case 3:
                Params newParams = new Params(theseParams.number - 1, 4);
                theStack.push(newParams);
                logicAddress = 2;
                break;
            case 4:
                theseParams = theStack.peek();
                theAnswer = theAnswer + theseParams.number;
                logicAddress = 5;
                break;
            case 5:
                theseParams = theStack.peek();
                logicAddress = theseParams.returnAddress;
                theStack.pop();
                break;
            case 6:
                return true;
        }
        return false;
    }

    public static String getString() throws IOException{
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        String s = br.readLine();
        return s;
    }
    public static int getInt() throws IOException{
        String s=getString();
        return Integer.parseInt(s);
    }
}
/**
 * 总结：
 * 当要求效率的时候可以把弟归转化为基于栈的非递归，进而可以把基于栈的转化为仅有循环的
 * 非递归，这种情况下效率是最高的。
 * 但是一些复杂的情况可以转化为基于栈的非递归，但是无法消除栈的。
 * 一些递归的算法是非常优秀的，比如分治算法。
 */