栈的应用之一——括号匹配

最后输入的左括号应该最先被匹配，满足后进先出，所以要用到栈

将输入的内容存到字符数组里， 从括号序列里依次取出，分为两种情况：

1. 凡是左括号，则进栈
2. 出现右括号，先检查栈是否为空。若为空，则该右括号多余，匹配失败；若不为空，则与栈顶元素比较，若相匹配，则左括号出栈，否则不匹配
3. 括号序列结束时，若栈为空，则表达式匹配正确，若不为空，则表明左括号有余，匹配失败。

创建两个类，一个定义栈，一个用于测试

注：

栈的长度=top+1

空栈时top=-1

栈满时 top=stackArray.length-1

top在元素进出栈时改变

stackArray 只在追加存储空间时改变

 

//定义栈
public class sequenceStack<T>{   
    private T[] stackArray;     //定义两个成员变量
    private int top;     //作为栈顶指针  空栈时为-1，非空时始终指向栈顶元素
    public sequenceStack(int n){    //栈的初始化（有参）
        if(n<=0){
            System.out.println("数据长度要大于0，否则退出程序运行！");
            System.exit(1);
        }
        top=-1;
        stackArray=(T[])new Object[n];
    }
    public void push(T obj){     //入栈   时间复杂度为O(1)，因为是直接插入
        if(top==stackArray.length-1){     //用于判断栈满
            T []p=(T[]) new Object[top*2+2];  //若栈满了创建一个容量为top*+2的新数组，并将元素移过去
            for(int i=0;i<=top;i++){
                p[i]=stackArray[i];          
            }
            stackArray=p;
        }
        top++;
        stackArray[top]=obj;

    }
    public T pop(){  //出栈
        if(top==-1){
            System.out.println("数据栈已空,无法删除数据");
            return null;

        }
        top--;
        return stackArray[top+1];
        //也可写成  T e =stackArray[top--];  return e;
    }
    public T getHead(){  //获取栈顶元素
        if (top==-1){
            System.out.println("数据栈已空无法获取元素");
            return null;

        }
       return stackArray[top];

    }
    public boolean isEmpty(){   //判断栈是否为空
        return top==-1;
    }
}

//测试类
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test {
    public static boolean matching(char[] exp){
        int state=1,i=0;
        sequenceStack<Character> s =new sequenceStack<Character>(10);  //声明栈
        while(i<exp.length&&state==1){
            switch (exp[i]){
                case'[':
                case'(':
                {
                    s.push(exp[i]);
                    i++;
                    break;

                }
                case']':
                {
                    if(!s.isEmpty()){
                        if(s.getHead()=='['){
                            s.pop();
                            i++;
                        }
                        else state=0;
                    }
                    else state=0;
                    break;
                }
                case')':
                {
                    if(!s.isEmpty()){
                        if(s.getHead()=='('){
                            s.pop();
                            i++;
                        }
                        else state=0;
                    }
                    else state=0;
                    break;
                }
                default:{
                    i++;
                    break;
                }
            }
        }
        if(s.isEmpty()&& state==1)
            return true;
        else return false;

    }
    public static void main(String []args){
        BufferedReader br;
        String s;
        char[]us;
        try{
            br=new BufferedReader(new InputStreamReader(System.in));  //br为具有缓冲功能的输入流
            System.out.print("输入一个含有()和[]的表达式");
            s=br.readLine();
            us=s.toCharArray();      //转化为字符数组
            if(matching(us))
                System.out.println("表达式括号匹配");
            else
                System.out.println("表达式括号不匹配");

        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

}