栈与队列 栈

栈：先进后出，后进先出。

public class Stack {

    private int maxSize;
    private int[] stackArray;
    private int top;
    
    public Stack(int s){
    　　this.maxSize = s;
    　　stackArray = new int[maxSize];
    　　top = -1;
    }
    
    public void push(int d){
    　　stackArray[++top] = d;
    }
    
    public int pop(){
    　　return stackArray[top--];
    }
    
    public int peek(){
    　　return stackArray[top];
    }
    
    public boolean isFull(){
    　　return top == maxSize-1;
    }
    
    public boolean isEmpty(){
    　　return top == -1;
    }
    
}

    public static void main(String[] args) {
    　　Stack stack = new Stack(5);
    　　stack.push(1);
    　　stack.push(2);
    　　stack.push(3);
    　　stack.push(4);
    　　while (!stack.isEmpty()) {
        　　System.out.println(stack.pop());
    　　}
    }

打印结果：
4
3
2
1

栈的应用：分隔符匹配

class BracketChecker {
    private String input;

    public BracketChecker(String s) {
    　　this.input = s;
    }

    public void check() {
    　　int size = input.length();
    　　Stack stack = new Stack(size);
    　　for (int i = 0; i < size; i++) {
        　　char c = input.charAt(i);
        　　switch (c) {
        　　　　case '{':
        　　　　case '[':
        　　　　case '(':
        　　　　　　stack.push(c);
        　　　　　　break;
        　　　　case '}':
        　　　　case ']':
        　　　　case ')':
        　　　　　　if (!stack.isEmpty()) {
            　　　　　　char cx = (char) stack.pop();
            　　　　　　if ((c == '{' && cx != '}') || (c == '[' && cx != ']')
                　　　　　　|| (c == '(' && cx != ')')) {
            　　　　　　System.out.println("Error : " + c + " at " + i);
            　　　　　　}
        　　　　　　} else {
            　　　　　　System.out.println("Error : " + c + " at " + i);
        　　　　　　}
        　　　　　　break;
        　　　　default:
        　　　　break;
        　　}
    　　}
    　　if (!stack.isEmpty()) {
        　　System.out.println("Error : missing right delimiter .");
    　　}
    }
}

    public static void main(String[] args) {
    　　String input = "{ab[c](e)}d}";
    　　BracketChecker checker = new BracketChecker(input);
    　　checker.check();
    }

打印结果：
Error : } at 11

栈的效率：
数据项入栈和出栈的时间复杂度都为常数O(1)。也就是说，栈操作所花的时间不依赖与栈中数据项的个数，因此操作时间很短，栈不需要比较和移动操作。