栈与栈的一些典型应用

栈的特点

• 栈属于线性序列结构。可基于链表或者向量结构实现。
• 栈中元素的操作次序始终遵循“后进先出”（last-in-first-out）

 /**
 *基于链表实现栈
 */
 import java.util.LinkedList;

public class StackBaseLinkedList<E> {
    private LinkedList<E> storage = null;

    public StackBaseLinkedList() {
        storage = new LinkedList<E>();
    }

    public int size() {
        return storage.size();
    }

    public boolean empty() {
        return storage.isEmpty();
    }
    /**
     * LinkedList中于栈相关的源码可以看出Java官方的栈底是first，栈顶是last。
     * 将对象压入栈
     * */
    public void push(E e) {
        storage.addFirst(e);
    }
    /**
     * 返回并删除栈顶对象
     * */
    public E pop() {
        return storage.removeFirst();
    }
    /**
     * 引用栈顶对象但是不删除
     * */
    public E top() {
        return storage.getFirst();
    }   
}

函数调用栈

在windos等大部分操作系统中，每个运行中的二进制程序都配有一个调用栈(call stack)和执行栈(execution stack)。借助调用栈可以跟踪属于同一程序的所有函数(书P88图)。

调用栈的基本单位是帧(frame)。每次函数调用时，都会相应地创建一帧，记录该函数实例在二进制程序中的返回地址(return address)，以及局部变量、传入参数等，并将该帧压入调用栈。函数一旦运行完毕，对应的帧随即弹出，运行控制权将被交还给函数的上层调用函数，并按照该帧中记录的返回地址确定在二进制程序中继续执行的位置。

位于调用栈栈底的那帧必然对应于入口主函数main()，若它从调用栈中弹出，则意味着整个程序的运行结束，此后控制权将交还给操作系统。

栈的典型应用

• 栈擅长解决的典型问题具有以下共同特征
  
  • 有明确的算法，但其解答却以线性序列的形式给出
  • 无论是递归还是迭代实现，该序列都是依逆序计算输出

* 输入和输出规模不确定，难以事先确定盛放输出数据的容器大小

进制转换

    /**
     * 十进制转换为任意进制
     * */
    public void convert(int e, int base) {
        final char[] digit = {'0','1','2','3','4','5','6','7','8'
                ,'9','A','B','C','D','F'};
        StackBaseLinkedList<Character> sbll = new StackBaseLinkedList<Character>();
        StringBuffer sb = new StringBuffer();
        int remainder;

        while(e > 0) {
            remainder = e % base;
            sbll.push(digit[remainder]);
            e = e / base;
        }
        while(!sbll.empty()) {
            sb.append(sbll.pop());
        }
        System.out.print(sb.toString());
    }

括号匹配（栈混洗）

当遇到{ [ ( 时，将其压进栈

当遇见} ] ) 时，或栈顶元素不为null并且是与其匹配的左半部分，则将栈顶元素pop。否则括号不匹配。

    /**
     * 括号匹配，能匹配的括号有()[]{};
     * */
    public boolean paren(String s) {

        StackBaseLinkedList<Character> sbll = new StackBaseLinkedList<Character>();

        for(int lo = 0 ; lo < s.length() ; lo++) {
            switch(s.charAt(lo)) {
                case '(' :
                case '[' :
                case '{' : sbll.push(s.charAt(lo));                 
                    break;
                //当存在右括号而栈为空时，直接返回false
                case ')' : if(sbll.empty() || '(' != sbll.pop()) return false;
                    break;                          
                case ']' : if(sbll.empty() || '[' != sbll.pop()) return false;
                    break;
                case '}' : if(sbll.empty() || '{' != sbll.pop()) return false;
                    break;
            }
        }   
        return sbll.empty();
    }

中缀表达式求值

将运算表达式的运算符与运算数分别压入两个不同的栈optr与opnd。

根据oprt栈顶元素与当前操作符查表得到优先级次序’<’,’=’,’>’。

运算优先级’<’:当前运算符优先级别更高，不能进行运算。将其压入栈optr

运算优先级’=’:当前运算符优先级相等，只存在于左右括号的匹配和为了方便算法处理引入的左右哨兵匹配。

运算优先级’>’:当前运算符优先级较低，执行栈顶运算符的运算

    //运算优先级表
    private final char[][] pri = {
        /*           |----------------当前运算符----------------|*/
        /*             +   -   *   /   ^   !   (   )  \0        */
        /*--  +*/    {'>','>','<','<','<','<','<','>','>'},
        /*|  -*/     {'>','>','<','<','<','<','<','>','>'},
        /*栈   **/     {'>','>','>','>','<','<','<','>','>'},
        /*顶   /*/     {'>','>','>','>','<','<','<','>','>'},
        /*运   ^*/     {'>','>','>','>','>','<','<','>','>'},
        /*算   !*/     {'>','>','>','>','>','>',' ','>','>'},
        /*符    (*/     {'<','<','<','<','<','<','<','=',' '},
        /*|   )*/    {' ',' ',' ',' ',' ',' ',' ',' ',' '},
        /*--  \0*/    {'<','<','<','<','<','<','<',' ','='}
    };

    /**
     * 中缀表达式求值，并产生逆波兰式RPN
     * 
     */
    public int evaluate(String s,ArrayList<String> RPN) {
        //用来存放运算数的栈
        StackBaseLinkedList<Integer> opnd = new StackBaseLinkedList<Integer>();
        //用来存放运算符的栈
        StackBaseLinkedList<Character> optr = new StackBaseLinkedList<Character>();     
        char op ;
        int p0opnd,p1opnd,lo = 0;
        //添加右哨兵，方便算法。否则需要额外处理数组脚标越界问题
        s = s + "\0";
        //添加左哨兵，方便算法
        optr.push('\0');
        //循环条件有问题，最后一位是运算符号时会少算一次
//      for(int lo = 0 ; lo < s.length() ;) {
        while(!optr.empty()) {
            if(isDigit(s.charAt(lo))) {
                lo = readNumber(s,lo,opnd); 
                append(RPN,opnd.top());
            } else {
                switch(orderBetween(optr.top(),s.charAt(lo))) {
                    case '<' : optr.push(s.charAt(lo));
                        lo++;
                        break;
                    //只有左右括号或者表达式结束才会出现'='
                    case '=' : optr.pop();
                        lo++;
                        break;
                    //栈顶运算符优先于当前运算符，先处理栈顶运算符
                    case '>' : op = optr.pop();
                        append(RPN,op);
                        if(op == '!') {
                            //一元运算符
                            p0opnd = opnd.pop();
                            opnd.push(calcu(op,p0opnd));
                        } else {
                            //二元运算符
                            p0opnd = opnd.pop();
                            p1opnd = opnd.pop();
                            opnd.push(calcu(op,p0opnd,p1opnd));
                        }
                        break;
                    default : System.exit(1);
                }
            }
        }
        return opnd.pop();
    }
    private boolean isDigit(char c) {
        // (int)'0' = 48 , (int)'9' = 57
        if((int)c < 58 && (int)c > 47) {
            return true;
        } else {
            return false;
        }
    }
    private char orderBetween(char op1,char op2) {
        return pri[oprtRank(op1)][oprtRank(op2)];
    }
    private int oprtRank(char op) {
        switch(op) {
            case '+' : return 0;
            case '-' : return 1;
            case '*' : return 2;
            case '/' : return 3;
            case '^' : return 4;
            case '!' : return 5;
            case '(' : return 6;
            case ')' : return 7;
            case '\0': return 8;
        }
        return -1;
    }
    private int readNumber(String s,int lo,StackBaseLinkedList<Integer> opnd) {
        int temp = 0, i = lo;
        opnd.push((int)s.charAt(i) - 48);
        while((++i < s.length()) && isDigit(s.charAt(i))) {
            temp = opnd.pop();
            temp = temp * 10 + ((int)s.charAt(i) - 48);
            opnd.push(temp);
        }
        return i;
    }   
    public int calcu(char op,int p0pnd) {
        // 0的阶乘等于1
        if(p0pnd == 0 ) {
            return 1;
        }
        for(int i = p0pnd - 1 ; i > 0 ; i--) {
            p0pnd = p0pnd * i;
        }
        return p0pnd;
    }       
    private int calcu(char op,int p0opnd,int p1opnd) {
        int j = p1opnd;
        switch(op) {
            case '+' : return p1opnd + p0opnd;
            case '-' : return p1opnd - p0opnd;
            case '*' : return p1opnd * p0opnd;
            case '/' : return p1opnd / p0opnd;
            case '^' : 
                for(int i = 0 ; i < p0opnd - 1 ; i++) {
                    p1opnd = p1opnd * j;
                }
                break;
        }
        return p1opnd;
    }   
}
    private void append(ArrayList<String> RPN,int opnd) {
        RPN.add(Integer.toString(opnd));
    }
    private void append(ArrayList<String> RPN,char op) {
        RPN.add(Character.toString(op));
    }

逆波兰式求值

    /**
     * RPN式求值
     * 这里RPN表达式不能用StringBuffer,StringBuffer无法分辨个位数与多位数。
     * */
    public int rpnEvaluation(ArrayList<String> RPN) {
        StackBaseLinkedList<Integer> s = new StackBaseLinkedList<Integer>();
        int p0opnd,p1opnd,lo = 0;
        char op;
        while(lo < RPN.size()) {
            op = RPN.get(lo).charAt(0);
            if(Character.isDigit(op)) {
                s.push(Integer.parseInt(RPN.get(lo))); 
                lo++;
            } else {
                if(op == '!') {
                    //一元运算符
                    p0opnd = s.pop();                   
                    s.push(calcu(op,p0opnd));
                } else {
                    //二元运算符
                    p0opnd = s.pop();
                    p1opnd = s.pop();
                    s.push(calcu(op,p0opnd,p1opnd));
                }
                lo++;
            }
        }

        return s.pop();
    }