Applications of Stack

 

1. Recursive Procedures

　　To see how a stack can be used to implement recursive procedures in a non-recursive way, we take Hanoi Tower Problem for example:

public class Main {
    public static class Hanoi {
        public int start;
        public int dest;
        public int num;
        
        public Hanoi(int start,int dest,int num) {
            this.start = start;
            this.dest = dest;
            this.num = num;
        }
        public String toString() {
            return "Move from "+printStack(start)+" to "+printStack(dest);
        }
        private String printStack(int idx) {
            switch (idx) {
            case 0:    return "A";
            case 1:    return "B";
            case 2:    return "C";
            default:
                return null;
            }
        }
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Stack<Hanoi> stack = new Stack<Hanoi>();
        System.out.print("Input the number of disks:\n\t");
        stack.push(new Hanoi(0,2,in.nextInt()));
        while (!stack.isEmpty()) {
            Hanoi h = stack.pop();
            if (h.num==1) {
                System.out.println(h);
            } else {
                int tmp = 3-h.start-h.dest;
                stack.push(new Hanoi(tmp,h.dest,h.num-1));
                stack.push(new Hanoi(h.start,h.dest,1));
                stack.push(new Hanoi(h.start,tmp,h.num-1));
            }
        }
        in.close();
    }
}

 

2. Event-Driven Simulation

　　Similar to queues, stacks are also widely used in event-driven simulations. Here, I cite an example from SJTU ACM Online Judge:

import java.util.*;

public class Main {
    public static int [] arr;
    
    public static boolean test(int num,int size)  {
        Stack<Integer> stack = new Stack<Integer>();
        int come = 0;        // the number of a coming train
        for (int i=0;i<num;i++) {
            // For each loop, a desired train departs from the station
            if (!stack.isEmpty() &&arr[i]==stack.peek().intValue()) {
                // first, consider the top of the stack
                stack.pop(); 
                size++;
                continue;
            }
            while (arr[i]!=come++) {
                // next, look forward to a new-comer
                if (come==num) {
                    // no more new-comers
                    return false;
                }
                stack.push(new Integer(come-1));
                if (--size<0) {
                    // no space for new-comers
                    return false;
                }
            }
        }
        return true;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int testNum = in.nextInt();
        arr = new int [1024];
        for (int i=0;i<testNum;i++) {
            int num = in.nextInt();
            int size = in.nextInt();
            for (int j=0;j<num;j++) {
                arr[j] = in.nextInt();
            }
            if (test(num,size)) {
                System.out.println("YES");
            } else {
                System.out.println("NO");
            }
        }
        in.close();
    }
}

 

3. Infix Expression Calculation

　　This program first converts an infix expression into a suffix expression with the help of an operator stack, and then calculates the suffix expression by using an operand stack.

 

　　Sample Input and Output:

　　

 

import java.util.*;
import java.io.*;

class Suffix {
    private Stack<Integer> stack;
    
    public Suffix() {
        stack = new Stack<Integer>();
    }
    public void addToken(String str) {
        if (str.equals("+") || str.equals("-") || str.equals("*") ||
                str.equals("/") || str.equals("^")) {
            int b = stack.pop().intValue();
            int a = stack.pop().intValue();
            if (str.equals("+")) {
                stack.add(new Integer(a+b));
            } else if (str.equals("-")) {
                stack.add(new Integer(a-b));
            } else if (str.equals("*")) {
                stack.add(new Integer(a*b));
            } else if (str.equals("/")) {
                stack.add(new Integer(a/b));
            } else {
                int val = 1;
                for (int i=0;i<b;i++) {
                    val *= a;
                }
                stack.add(new Integer(val));
            }
        } else {    // an operand
            stack.add(Integer.valueOf(str));
        }
    }
    public int getVal() {
        return stack.peek().intValue();
    }
    public void clear() {
        stack.clear();
    }
}

public class InfixExpr {
    private static BufferedReader in;
    private static StringTokenizer tokenizer;
    private static Stack<String> stack;
    private static Suffix server;
    
    private static void printAndCal(String expr) {
        System.out.println(expr);
        tokenizer = new StringTokenizer(expr);
        // ATTENTION: we can't use a for-loop based on
        //        tokenizer.countTokens() since it is mutable
        while (tokenizer.hasMoreTokens()){
            String str = tokenizer.nextToken();
            if (str.equals("(")) {
                stack.add(str);
            } else if (str.equals(")")) {
                String op = stack.pop();
                while (!op.equals("(")) {
                    server.addToken(op);
                    op = stack.pop();
                }
            } else if (str.equals("+") || str.equals("-") || str.equals("*") ||
                str.equals("/") || str.equals("^")) {
                while (!stack.isEmpty()&&!stack.peek().equals("(")&&prior(stack.peek(),str)) {
                    server.addToken(stack.pop());
                }
                stack.add(str);
            } else {    // an operand
                server.addToken(str);
            }
        }
        while (!stack.isEmpty()) {
            server.addToken(stack.pop());
        }
        System.out.println(server.getVal());
    }
    private static boolean prior(String op1,String op2) {
        // Returns whether op1 can be operated first when
        //        it is aligned with operator op2
        if (op2.equals("^")) {
            return false;
        } else if (op2.equals("*")||op2.equals("/")) {
            return !op1.equals("+")&&!op1.equals("-");
        } else {    
            return true;
        }
    }
    public static void main(String[] args) throws IOException {
        in = new BufferedReader(new FileReader("infix.in"));
        stack = new Stack<String>();
        server = new Suffix();
        int n = Integer.parseInt(in.readLine());
        System.out.println(n);
        for (int i=0;i<n;i++) {
            server.clear();
            printAndCal(in.readLine());
        }
        in.close();
    }
}