Java堆栈的应用1----------堆栈的自定义实现以及括号匹配算法的Java实现

接下篇：http://www.cnblogs.com/fuck1/p/5995857.html

堆栈的应用1：括号匹配算法

括号匹配问题

假设算术表达式中包含圆括号，方括号，和花括号三种类型。使用栈数据结构编写一个算法判断表达式中括号是否正确匹配，并设计一个主函数测试。

比如：{a+[b+(c*a)/(d-e)]}     正确

         ([a+b)-(c*e)]+{a+b}    错误

   对于表达式中的括号是否匹配，不能仅仅通过统计左括号'('出现的次数和右括号')'出现的次数是否相等来实现，“a*)b+c(”这样的表达式中的括号显然是不匹配的。检验括号是否匹配最常见的方法是借助于栈这种数据结构，从左到右逐个字符扫描表达式，碰到左括号"("则压入栈中(push)，碰到右括号")"则弹出栈顶元素(pop)如果栈为空，则匹配失败。字符串扫描完成后，如果栈为空，则匹配成功，否则匹配失败。

//-------------------------------------------------------------在这里虽然Java给出了Stack的类但是还是自定义

//下面是一个stack接口的定义

//栈接口
public interface Stack {

    // 入栈
    public void push(Object obj) throws Exception;

    // 出栈
    public Object pop() throws Exception;

    // 获得栈顶元素
    public Object getTop() throws Exception;

    // 判断栈是否为空
    public boolean isEmpty();
}

//顺序栈的具体实现，通过数组实现

//顺序栈

public class SequenceStack implements Stack {

    Object[] stack; // 对象数组
    final int defaultSize = 10; // 默认长度
    int top;// 栈顶位置
    int maxSize;// 最大长度

    public SequenceStack() {
        // 默认方法初始化
        init(defaultSize);
    }

    // 显示调用方法初始化
    public SequenceStack(int size) {
        // 根据用户传入的参数进行初始化
        init(size);
    }

    // 初始化方法
    private void init(int size) {
        this.maxSize = size;
        top = 0;
        stack = new Object[size];
    }

    // 入栈操作
    @Override
    public void push(Object obj) throws Exception {
        // TODO Auto-generated method stub
        // 判断栈是否已满
        if (top == maxSize) {
            throw new Exception("堆栈已满");
        }
        // 入栈
        stack[top] = obj;
        top++;
    }

    // 出栈
    @Override
    public Object pop() throws Exception {
        // TODO Auto-generated method stub
        // 判断栈是否为空
        if (isEmpty()) {
            throw new Exception("堆栈为空！");
        }
        // 因为在入栈之后默认将top值进行了++所以导致不指示当前位置
        top--;
        return stack[top];
    }

    // 获得栈顶元素
    @Override
    public Object getTop() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("堆栈为空！！");
        }
        // 单纯获得栈顶元素
        return stack[top - 1];
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return top == 0;
    }

}

//获得栈的具体使用操作后，下面使用堆栈完成对括号匹配算法的使用:

import java.util.Scanner;

//平衡符号算好，检查算数式的括号是否是正确的，小括号，中括号，大括号
public class Test {
    public static void main(String[] args) throws Exception {
        String str = "{a + [b + ( c * a ) / ( d * e)]}";
        String str2 = "{a+(a*B)+[a-1] + }";

        signCheck(str2);
    }

    // 字符串检查
    public static void signCheck(String str) throws Exception {
        SequenceStack stack = new SequenceStack();
        String[] arr = expToStringArray(str);
        for (int i = 0; i < arr.length; i++) {
            // 如果数组中有这三种左括号元素那么直接进行入栈操作
            if (arr[i].equals("(") || arr[i].equals("[") || arr[i].equals("{")) {
                stack.push(arr[i]);
            }

            else if (arr[i].equals(")") && !stack.isEmpty()
                    && stack.getTop().equals("(")) {
                // 上面的if判断主要是当我们遇到右括号时，发现当前位于栈顶的是左括号，那么此时可以出栈了
                stack.pop();
            }

            else if (arr[i].equals(")") && !stack.isEmpty()
                    && !stack.getTop().equals("(")) {

                System.out.println("左右括号匹配次序不成功");
                return;
            }
            // 遇到中括号时
            else if (arr[i].equals("]") && !stack.isEmpty()
                    && stack.getTop().equals("[")) {
                // 上面的if判断主要是当我们遇到右括号时，发现当前位于栈顶的是左括号，那么此时可以出栈了
                stack.pop();
            }

            else if (arr[i].equals("]") && !stack.isEmpty()
                    && !stack.getTop().equals("[")) {

                System.out.println("左右括号匹配次序不成功");
                return;
            }

            // 大括号匹配
            else if (arr[i].equals("}") && !stack.isEmpty()
                    && stack.getTop().equals("{")) {
                // 上面的if判断主要是当我们遇到右括号时，发现当前位于栈顶的是左括号，那么此时可以出栈了
                stack.pop();
            }

            else if (arr[i].equals("}") && !stack.isEmpty()
                    && !stack.getTop().equals("{")) {

                System.out.println("左右括号匹配次序不成功");
                return;
            }

            // 右括号多于左括号的情况
            else if (arr[i].equals(")") || arr[i].equals("]")
                    || arr[i].equals("}") && stack.isEmpty()) {
                System.out.println("右括号多于左括号");
                return;
            }
        }
        // 经历完一趟循环后如果堆栈不为空，那么左括号就多了
        if (!stack.isEmpty()) {
            System.out.println("左括号多于右括号");
        } else {
            System.out.println("匹配正确");
        }

    }

    // 字符串转为字符串数组
    public static String[] expToStringArray(String exp) {
        // 字符串数组长度
        int n = exp.length();
        String[] arr = new String[n];
        for (int i = 0; i < n; i++) {
            arr[i] = exp.substring(i, i + 1);
        }

        return arr;
    }
}