栈实现java

　　栈是一种“先去后出”的抽象的数据结构。例如：我们在洗盘子的时候，洗完一个盘子，将其放在一摞盘子的最上面，但我们全部洗完后，要是有盘子时，我们会先从最上面的盘子开始使用，这种例子就像栈的数据结构一样，先放进去的数据，最后才能得到。

栈不仅在生活中有很多例子，在计算机方面使用的更为频繁。如：大部分处理器运用基于栈的体系结构，当调用一个方法时，把他的返回地址和参数压入栈，当方法结束返回时，那些数据出栈。栈操作就嵌入在微处理器中。还有比如较老的计算器也是这样，他们不是输入带括号的算术表达式，而是把中间结果先存入栈中等等。

　　栈原理图示：

栈代码实现（下面还有分隔符匹配例子的代码）：

栈类实现：

package com.dxx.stack;

public class StackX {
    private int maxSize;
    private int[] stackArray;
    private int top;

//构造器中初始化栈的数组，并将栈定索引置为-1，表示栈为空。
    public StackX(int maxSize) {
        super();
        this.maxSize = maxSize;
        stackArray = new int[maxSize];
        top = -1;
    }
    //判断栈是否为空，在出栈操作前都要先判断栈是否空，若为空，则不能出栈。
    public boolean isEmpty(){
        if(top == -1)
            return true;
        return false;
    }
    //判断栈是否已满，在入栈操作前都要先判断栈是否已满，若已满，则不能入栈。
    public boolean isFull(){
        if(top == maxSize-1)
            return true;
        return false;
    }
    //入栈
    public void push(int num){
        if(!isFull()){
            stackArray[++top] = num;
        }else {
            System.out.println("栈已满，不能再进行入栈操作。");
        }
    }
    //出栈
    public int pop(){
        if(!isEmpty()){
            return stackArray[top--];
        }else {
            System.out.println("栈为空，不能获取栈定元素");  return 0;
        }
    }
    //取栈顶元素
    public int peek(){
        if(!isEmpty()){
            return stackArray[top];
        }else {
            System.out.println("栈为空，不能获取栈定元素");    return 0;
        }
    }

}

主程序测试：

package com.dxx.stack;

public class StackMain {

    public static void main(String[] args) {
        StackX stackX = new StackX(5);
        stackX.peek();
        stackX.push(0);
        stackX.push(1);
        stackX.push(2);
        stackX.push(3);
        stackX.push(4);
        stackX.push(5);
        System.out.println(stackX.pop());
        System.out.println(stackX.pop());
        System.out.println(stackX.pop());
    }

}

输出结果：

栈为空，不能获取栈定元素
栈已满，不能再进行入栈操作。
4
3
2

下面就是分隔符匹配的例子代码：

分析：

分隔符栈的类：

package com.dxx.stack;

public class BracketStackX {
    private int maxSize;
    private char[] stackArray;
    private int top;

//构造器中初始化栈的数组，并将栈定索引置为-1，表示栈为空。
    public BracketStackX(int maxSize) {
        super();
        this.maxSize = maxSize;
        stackArray = new char[maxSize];
        top = -1;
    }
    //判断栈是否为空，在出栈操作前都要先判断栈是否空，若为空，则不能出栈。
    public boolean isEmpty(){
        if(top == -1)
            return true;
        return false;
    }
    //判断栈是否已满，在入栈操作前都要先判断栈是否已满，若已满，则不能入栈。
    public boolean isFull(){
        if(top == maxSize-1)
            return true;
        return false;
    }
    //入栈
    public void push(char ch){
        if(!isFull()){
            stackArray[++top] = ch;
        }else {
            System.out.println("栈已满，不能再进行入栈操作。");
        }
    }
    //出栈
    public char pop(){
        if(!isEmpty()){
            return stackArray[top--];
        }else {
            System.out.println("栈为空，不能获取栈定元素");  return 0;
        }
    }
    //取栈顶元素
    public char peek(){
        if(!isEmpty()){
            return stackArray[top];
        }else {
            System.out.println("栈为空，不能获取栈定元素");    return 0;
        }
    }
}

字符串匹配检查类：

package com.dxx.stack;
//定义一个检查分隔符是否匹配的工具栏
public class BracketCheck {
    private String input;

    public BracketCheck(String input) {
        super();
        this.input = input;
    }

    public boolean chek(){
        //先实例化有关分隔符的栈
        BracketStackX stackX = new BracketStackX(input.length());
        //依次比较input的字符，如果是左分隔符，就入栈，是右分隔符，就出栈与右分隔符匹配。
        for(int i=0; i<input.length(); i++){
            char ch = input.charAt(i);
            switch(ch){
            case '{':
            case '[':
            case '(':
                stackX.push(ch);
                break;
            case ')':
            case ']':
            case '}':
                char ch2 = stackX.pop();
                if(ch==')'&&ch2=='(' ||ch==']'&&ch2=='[' ||ch=='}'&&ch2=='{'){
                }else {
                    return false;
                }
                break;
            }
        }
        if(!stackX.isEmpty()){
            return false;
        }
        return true;

    }

}

主程序测试：

package com.dxx.stack;

public class StackMain {

    public static void main(String[] args) {
        BracketCheck bracketCheck = new BracketCheck("123{{[4444(3333)fff]ddddd}");
        if(bracketCheck.chek())
            System.out.println("匹配");
        else
            System.out.println("不匹配");
    }

}

结果为：不匹配。

大家有兴趣还可以练习一个单子逆序显示。