使用栈进行括号匹配java

使用到的类：

• 接口和顺序栈类
• 匹配类
• 顺序表类
• 主类

---

运行结果

---

匹配类

package Class.Stack.Match;

import Class.LinearList.LinearList;
import Class.Stack.SeqStack.SeqStack;

public class BracketMatch {
    // [??(??)??]
    /*
        1. 如果是左括号直接入栈
        2. 如果是右括号则和栈顶元素比较
            a. 如果匹配则继续遍历
            b. 如果不匹配返回false
     */
    SeqStack bracketStack;

    public boolean match(String str) {
        // 创建所用栈
        SeqStack bracketStack = new SeqStack(new LinearList(str.length()));
        for (int i = 0; i < str.length(); i++) {
            char temp = str.charAt(i);
            switch (temp) {
                case '[':
                case '(':
                case '{':
                    bracketStack.push(temp);
                    break;
                case ']':
                    char leftBracket1 = (char)bracketStack.pop();
                    if(leftBracket1 == '[') {
                        break;
                    }
                    System.out.println(leftBracket1 + "与]符号不匹配");
                    return false;
                case ')':
                    char leftBracket2 = (char)bracketStack.pop();
                    if(leftBracket2 == '(') {
                        break;
                    }
                    System.out.println(leftBracket2 + "与)符号不匹配");
                    return false;
                case '}' :
                    char leftBracket3 = (char)bracketStack.pop();
                    if(leftBracket3 == '{') {
                        break;
                    }
                    System.out.println(leftBracket3 + "与}符号不匹配");
                    return false;
            }
        }
        System.out.println("表达式正确!");
        return true;
    }
}

---

接口和顺序栈类

package Class.Stack;

public interface Stack {
    public abstract boolean isEmpty();
    public abstract void push(int num);  // 入栈
    public abstract int pop(); // 出栈, 并得到该元素
    public abstract int peek(); // 返回顶端元素
}

package Class.Stack.SeqStack;

import Class.LinearList.LinearList;
import Class.Stack.Stack;

// 顺序栈, 即用顺序表存储元素, 使用前面顺序表中编好的方法.
public class SeqStack implements Stack {
    private LinearList linearList;

    public SeqStack(LinearList linearList) {
        this.linearList = linearList;
    }

    // 栈是否为空-->顺序表是否为空
    @Override
    public boolean isEmpty() {
        return linearList.isEmpty();
    }

    // 入栈--->往顺序表尾端插入数据
    @Override
    public void push(int num) {
        linearList.tailInsert(num);
    }

    // 出栈--->删除顺序表尾端元素并返回
    @Override
    public int pop() {
        return linearList.tailPop();
    }

    // 查看顶端元素--->查看顺序表尾端元素
    @Override
    public int peek() {
        return linearList.getInt(linearList.length - 1);
    }

    public int length() {
        return linearList.size();
    }
}

---

顺序表类

package Class.LinearList;

public class LinearList {
    public int length = 0;
    private int[] arr;
    private static final int MIN_CAPACITY = 3;

    // 构造方法一
    public LinearList(int length) {
        if (length >= MIN_CAPACITY) {
            arr = new int[length];
        } else {
            System.out.println("要求线性表最小长度为3!");
        }
    }

    // 构造方法二
    public LinearList() {
        this(MIN_CAPACITY);
    }
    // 构造方法三
    public LinearList(int []arr) {
        if(arr.length <= MIN_CAPACITY) {
            throw new RuntimeException("队列长度过小!");
        }
        this.arr = arr;
        length = arr.length;
    }

    public int getCapacity() {
        return arr.length;
    }

    //判断线性表是否为空
    public boolean isEmpty() {
        return length == 0;
    }

    // 判断线性表是否为满
    public boolean isFull() {
        return length == arr.length;
    }

    // 返回线性表长度
    public int size() {
        return length;
    }

    // 返回首个与key相等的元素的索引，查找不成功，返回null(这里是0)
    public int keySearch(int key) {
        if (isEmpty()) {
            throw new RuntimeException("线性表为空!");
        }
        for (int i = 0; i < length; i++) {
            if (arr[i] == key) {
                return i;
            }
        }
        System.out.println("线性表中没有该元素");
        return 0;
    }

    // 删除首个与key相等的元素的
    public void keyRemove(int key) {
        if (isEmpty()) {
            System.out.println("线性表为空!");
            return;
        }
        for (int i = 0; i < length; i++) {
            if (arr[i] == key) {
                arr[i] = 0;
                length--;
                return;
            }
        }
        System.out.println("线性表中没有该元素");
    }

    // 插入value，作为第n个元素
    public void insert(int value, int n) {
        if (isFull()) {
            System.out.println("线性表已满");
            return;
        }
        // 插入位置
        if (n >= 1 && n <= length + 1) {
            for (int i = length; i >= n; i--) {
                arr[i] = arr[i - 1];
            }
            arr[n - 1] = value;
        } else if (n > length + 1) {
            System.out.println("插入位置过大，自动插入到尾部");
            this.insert(value, length + 1);
        } else if (n < 1) {
            System.out.println("插入位置过小，自动插入到头部");
            this.insert(value, 1);
        }
        length++;
    }

    // 在尾部插入value元素
    public void tailInsert(int value) {
        this.insert(value, length + 1);
    }

    // 删除第n个元素
    public int remove(int n) {
        if (isEmpty()) {
            throw new RuntimeException("线性表为空!");
        }
        if (n >= 1 && n <= length) {
            int temp = arr[n - 1];
            for (int i = n - 1; i <= length - 2; i++) {
                arr[i] = arr[i + 1];
            }
            arr[length - 1] = 0;
            length--;
            return temp;
        } else {
            throw new RuntimeException("删除位置有误");
        }
    }

    // 顺序栈需求--->删除最后的元素(栈的顶部)并返回
    public int tailPop() {
        int tail = remove(length);
        return tail;
    }

    // 设置第n个元素为value
    public void setValue(int value, int n) {
        if (isEmpty()) {
            System.out.println("当前线性表为空");
        }
        if (n > length || n < 1) {
            System.out.println("访问越界");
            return;
        } else {
            arr[n - 1] = value;
        }
    }

    //
    public void showInfo() {
        for (int i = 0; i < length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println("");
    }

    //
    public int getInt(int index) {
        return arr[index];
    }

}

---

主类

package Class.Stack.Match;

public class Main {
    public static void main(String[] args) {
        BracketMatch tool = new BracketMatch();
        System.out.println(tool.match("{(1+2)}*3"));
        System.out.println("-----------");
        System.out.println(tool.match("{1+2)}*3"));
        System.out.println("-----------");
        System.out.println(tool.match("(1+2)*[2+2]*{[3-2]}"));
    }
}