堆栈应用——括号匹配问题

　　堆栈是各种软件系统中应用最广泛的数据结构之一。括号匹配问题和表达式计算是编译软件中的基本问题，其软件设计中都需要用到堆栈。

【括号匹配问题】

　　假设一个算术表达式中包含圆括号、方括号和花括号三种类型括号，编写一个判别表达式中括号是否正确匹配配对的函数，并设计一个测试主函数。

【设计分析】 括号匹配后到的括号要最先被匹配，满足堆栈“后进先出”的操作特点。

　　括号匹配有以下4种情况：

　　（1）左右括号配对次序不正确；

　　（2）右括号多于左括号；

　　（3）左括号多于右括号；

　　（4）括号匹配正确。

　　

【源代码】

SeqStackTest.java

package seqstack;

public class SeqStackTest { 
    //遍历字符数组并利用进栈出栈匹配括号  
    static void expIsCorrect(String[] exp,int n)throws Exception{  
        SeqStack myStack = new SeqStack(100);  
        //LinStack myStack = new LinStack(); //也可以用链式堆栈  
        for(int i=0;i<n;i++){//如果是左括号就入栈  
            if((exp[i].equals(new String("(")))  
                    || (exp[i].equals(new String("[")))  
                    || (exp[i].equals(new String("{"))))  
                myStack.push(exp[i]);  
            //如果是右括号）并且和栈顶（匹配，出栈  
            else if((exp[i].equals(new String(")"))) && myStack.notEmpty()  
                    && myStack.getTop().equals(new String("(")))  
                myStack.pop();  
            //遍历的右括号)和栈顶不匹配，说明公式错误，结束遍历  
            else if((exp[i].equals(new String(")"))) && myStack.notEmpty()  
                    && !myStack.getTop().equals(new String("("))){  
                System.out.println("左右括号匹配次序不正确！");  
                return;  
            }  
            //如果是右括号]并且和栈顶[匹配，出栈  
            else if((exp[i].equals(new String("]"))) && myStack.notEmpty()  
                    && myStack.getTop().equals(new String("[")))  
                myStack.pop();  
            //遍历的右括号]和栈顶不匹配，说明公式错误，结束遍历  
            else if((exp[i].equals(new String("]"))) && myStack.notEmpty()  
                    && !myStack.getTop().equals(new String("["))){  
                System.out.println("左右括号匹配次序不正确！");  
                return;  
            }  
            //如果是右括号}并且和栈顶{匹配，出栈  
            else if((exp[i].equals(new String("}"))) && myStack.notEmpty()  
                    && myStack.getTop().equals(new String("{")))  
                myStack.pop();  
            //遍历的右括号}和栈顶不匹配，说明公式错误，结束遍历  
            else if((exp[i].equals(new String("}"))) && myStack.notEmpty()  
                    && !myStack.getTop().equals(new String("{"))){  
                System.out.println("左右括号匹配次序不正确！");  
                return;  
            }  
            //如果栈已空，但还存在右括号，说明右括号多了  
            else if((exp[i].equals(new String(")")))  
                    || (exp[i].equals(new String("]")))  
                    || (exp[i].equals(new String("}")))  
                    && !myStack.notEmpty()){  
                System.out.println("右括号多余左括号!");  
                return;  
            }  
        }  
        //遍历完成后栈内还有元素，说明左括号多了  
        if(myStack.notEmpty())  
            System.out.println("左括号多余右括号!");  
        else  
            System.out.println("括号匹配正确！");  
    }  
      
    private static String[] strToString(String str){//把字符串转换为String类型数组  
        //为什么不转换为字符数组char[]呢?  
        //因为只有String类型的数据才具有可比性，也就是能用equals  
        int n = str.length();  
        String[] a = new String[n];  
        for(int i=0;i<n;i++){  
            a[i] = str.substring(i,i+1);//取子串含头不含尾，故可以取出i位置的字符并返回字符串类型  
        }  
        return a;  
    }  
      
    public static void main(String[] args) {  
        String str;  
        int n;  
        try{  
            str = "(())abc{[}(){";//左右括号匹配次序不正确  
            n = str.length();  
            String[] a = strToString(str);  
            expIsCorrect(a,n);  
              
            str = "(()))abc{[]}";//右括号多余左括号  
            n = str.length();  
            String[] b = strToString(str);  
            expIsCorrect(b,n);  
              
            str = "(()()abc{[]}";//左括号多余右括号  
            n = str.length();  
            String[] c = strToString(str);  
            expIsCorrect(c,n);  
              
            str = "(())abc{[]}";//括号匹配正确！  
            n = str.length();  
            String[] d = strToString(str);  
            expIsCorrect(d,n);  
        }  
        catch(Exception e){  
            System.out.println(e.getMessage());  
        }  
  
    }  
}  

Stack.java

package seqstack;

public interface Stack {
    public void push(Object obj)throws Exception;
    public Object pop()throws Exception;
    public Object getTop()throws Exception;
    public boolean notEmpty();
}

SeqStack.java

package seqstack;

public class SeqStack implements Stack{
    final int defaultSize=10;
    int top;
    Object[] stack;
    int sizeMaxSize;
    
    public SeqStack(int sz)
    {
        initiate(sz);
    }

    private void initiate(int sz) {
        // TODO Auto-generated method stub
        sizeMaxSize=sz;
        top=0;
        stack=new Object[sz];
    }
    
    public void push(Object obj)throws Exception{
        if(top == sizeMaxSize)
        {
            throw new Exception("堆栈已满！");
        }
        stack[top] = obj;
        top++;
    }
    
    public Object pop()throws Exception{
        if(top == 0)
        {
            throw new Exception("堆栈已空！");
        }
        top--;
        return stack[top];
    }
    
    public Object getTop()throws Exception{
        if(top == 0)
        {
            throw new Exception("堆栈已空！");
        }
        return stack[top-1];
    }
    public boolean notEmpty(){
        return(top>0);
    }
    
    
}

【运行结果】