【数据结构与算法】括号匹配：栈的底层原理实现

括号匹配：栈的底层原理实现

Java
https://leetcode-cn.com/problems/valid-parentheses/solution/gua-hao-pi-pei-zhan-de-di-ceng-yuan-li-s-2ybl/

解题思路

基于数组实现一个能自动扩容的数组（Array）类，类中提供了基本的增删改查等操作和一些快捷方法，后构建栈（Stack）类，栈类使用之前的数组类来完成基础的入栈、出栈等功能。再由此实现本题逻辑。受判题机限制，全放在一个文件中了。

代码实现

class Solution {
    
    private class Array<E> {
        // 数据数组
        private E[] data;
        // 数组元素个数
        private int size;

        /**
         * 创建数组，并设置初始容量
         *
         * @param capacity 容量
         */
        public Array(int capacity) {
            this.data = (E[]) new Object[capacity];
        }

        /**
         * 使用默认容量10来创建数组
         */
        public Array() {
            this(10);
        }

        /**
         * 获取数组元素个数
         *
         * @return 元素个数
         */
        public int getSize() {
            return this.size;
        }

        /**
         * 获取数组容量
         *
         * @return 容量
         */
        public int getCapacity() {
            return this.data.length;
        }

        /**
         * 判断是否是空数组
         *
         * @return 是否为空
         */
        public boolean isEmpty() {
            return this.size == 0;
        }

        /**
         * 向数组末尾插入一个元素
         *
         * @param e 需要插入的元素
         */
        public void addLast(E e) {
            this.add(this.size, e);
        }

        /**
         * 向数组最前面插入一个元素
         *
         * @param e 需要插入的元素
         */
        public void addFirst(E e) {
            this.add(0, e);
        }

        /**
         * 向数组任意位置插入元素
         *
         * @param index 要插入的位置
         * @param e     要插入的元素
         */
        public void add(int index, E e) {
            // 判断索引在可插入范围内
            if (index < 0 || index > this.size) {
                throw new IllegalArgumentException("Add failed. Require index >= 0 and index =< size.");
            }

            // 判断容量是否满了
            if (size >= this.getCapacity()) {
                resize(this.getCapacity() * 2);
            }

            int i = this.size;
            while (i > index) {
                this.data[i] = this.data[i - 1];
                i--;
            }

            this.data[index] = e;
            this.size++;
        }

        /**
         * 重新调整数组的大小
         *
         * @param size 数组新的大小
         */
        private void resize(int size) {
            E[] newData = (E[]) new Object[size];
            for (int i = 0; i < this.size; i++) {
                newData[i] = this.data[i];
            }
            this.data = newData;
        }

        /**
         * 查找一个元素是否存在数组中
         *
         * @param e 要查找的元素
         * @return 是否存在数组中
         */
        public boolean contains(E e) {
            for (int i = 0; i < this.size; i++) {
                if (this.data[i].equals(e)) {
                    return true;
                }
            }
            return false;
        }

        /**
         * 查找一个元素的位置
         *
         * @param e 元素
         * @return 位置，未找到返回-1
         */
        public int find(E e) {
            for (int i = 0; i < this.size; i++) {
                if (this.data[i].equals(e)) {
                    return i;
                }
            }
            return -1;
        }

        /**
         * 找出这个元素的所有索引
         *
         * @param e 元素
         * @return 所有索引数组
         */
        public int[] findAll(E e) {
            int[] allIndex = new int[this.size];
            int index = 0;
            for (int i = 0; i < this.size; i++) {
                if (this.data[i].equals(e)) {
                    allIndex[index] = i;
                    index++;
                }
            }

            int[] res = new int[index];

            int i = 0;
            while (i < index) {
                res[i] = allIndex[i];
                i++;
            }

            return res;
        }

        /**
         * 删除一个指定位置的元素
         *
         * @param index 指定位置
         * @return 被删除的元素
         */
        public E remove(int index) {
            if (index < 0 || index >= this.size) {
                throw new IllegalArgumentException("Remove failed. index is illegal.");
            }
            E res = this.data[index];
            for (int i = index; i + 1 < this.size; i++) {
                this.data[i] = this.data[i + 1];
            }
            this.size--;

            // 判断是否要收紧内存
            // 个人认为比例常数跟增加的不一样可以防止临界点时候反复横跳消耗性能
            // 比较小的话是收紧内存
            /*
             * 通过后面的章节得知，这是一种复杂度震荡的现象，处理的话需要懒处理，我的这个
             * 处理方式还不够好
             * */
            //int resize = (int)(this.data.length/1.8);
            //if(this.size<resize){
            //    this.resize(resize);
            //}

            if (this.size < this.data.length / 4 && this.data.length / 2 != 0) {
                this.resize(this.data.length / 2);
            }

            return res;
        }

        /**
         * 快捷方法，删除第一个元素
         *
         * @return 被删除的元素值
         */
        public E removeFirst() {
            return remove(0);
        }

        /**
         * 快捷方法，删除最后一个元素
         *
         * @return 被删除的元素
         */
        public E removeLast() {
            return remove(this.size - 1);
        }

        /**
         * 删除一个元素，如果此元素存在
         *
         * @param e 要删除的元素
         * @return 被删除元素的索引
         */
        public int removeElement(E e) {
            int index = find(e);
            if (index != -1) {
                remove(index);
            }
            return index;
        }

        /**
         * 删除所有的这个元素
         *
         * @param e 元素
         * @return 被删除的索引数组
         */
        public int[] removeAllElement(E e) {
            int[] index = findAll(e);

            // 这里要保证index的排序是从小到大
            for (int i = index.length - 1; i >= 0; i--) {
                remove(index[i]);
            }

            return index;
        }

        /**
         * 获取数组中的元素
         *
         * @param index 元素索引
         * @return 元素
         */
        public E get(int index) {
            if (index < 0 || index >= this.size) {
                throw new IllegalArgumentException("Get failed, index is illegal");
            }

            return this.data[index];
        }

        /**
         * 获取最后一个元素
         * @return 最后一个元素
         */
        public E getLast(){
            return get(size-1);
        }

        /**
         * 获取最前一个元素
         * @return 最前一个元素
         */
        public E getFirst(){
            return get(0);
        }

        /**
         * 修改数组中的元素
         *
         * @param index 需要修改的索引
         * @param e     修改后的值
         */
        public void set(int index, E e) {
            if (index < 0 || index >= this.size) {
                throw new IllegalArgumentException("Set failed, index is illegal");
            }

            this.data[index] = e;
        }

        @Override
        public String toString() {
            StringBuilder res = new StringBuilder();
            res.append(String.format("Array : size = %d , capacity = %d
", this.size, this.getCapacity()));
            res.append("[");
            for (int i = 0; i < this.size; i++) {
                res.append(this.data[i]);
                if (i != this.size - 1) {
                    res.append(", ");
                }
            }
            res.append("]");
            return res.toString();
        }
    }

    private interface Stack <E> {
        /**
         * 入栈，向栈中添加一个元素
         * @param e 要添加的元素
         */
        void push(E e);

        /**
         * 出栈，从栈顶拿出一个元素
         * @return 拿出的元素
         */
        E pop();

        /**
         * 看一下栈顶的元素是谁
         * @return 栈顶的元素
         */
        E peek();

        /**
         * 获取栈中元素的个数
         * @return 元素个数
         */
        int getSize();

        /**
         * 看下栈是否为空
         * @return 栈是否为空
         */
        boolean isEmpty();
    }

    private class ArrayStack<E> implements Stack<E> {

        Array<E> array;

        public ArrayStack(int capacity){
            this.array = new Array<E>(capacity);
        }

        public ArrayStack(){
            this.array = new Array<E>();
        }

        /**
         * 入栈，向栈中添加一个元素
         *
         * @param e 要添加的元素
         */
        @Override
        public void push(E e) {
            this.array.addLast(e);
        }

        /**
         * 出栈，从栈顶拿出一个元素
         *
         * @return 拿出的元素
         */
        @Override
        public E pop() {
            return this.array.removeLast();
        }

        /**
         * 看一下栈顶的元素是谁
         *
         * @return 栈顶的元素
         */
        @Override
        public E peek() {
            return this.array.getLast();
        }

        /**
         * 获取栈中元素的个数
         *
         * @return 元素个数
         */
        @Override
        public int getSize() {
            return this.array.getSize();
        }

        /**
         * 看下栈是否为空
         *
         * @return 栈是否为空
         */
        @Override
        public boolean isEmpty() {
            return this.array.isEmpty();
        }

        /**
         * 获取栈容量
         * @return 容量
         */
        public int getCapacity(){
            return this.array.getCapacity();
        }

        @Override
        public String toString(){
            StringBuilder res = new StringBuilder();
            res.append(String.format("Array Stack : size = %d, capacity = %d
",this.getSize(),this.getCapacity()));
            res.append("[");
            for (int i=0;i<this.getSize();i++){
                res.append(this.array.get(i).toString());
                if(i!=this.getSize()-1){
                    res.append(", ");
                }
            }
            res.append("] top");

            return res.toString();
        }
    }


    public boolean isValid(String s) {
        ArrayStack<Character> stack = new ArrayStack<Character>();
        // 依次遍历字符串中的字符
        for (int i = 0; i < s.length(); i++) {
            char tag = s.charAt(i);

            if (tag == '(' || tag == '[' || tag == '{') {
                // 判断是为左括号则入栈
                stack.push(tag);
            } else {
                // 否则看是否匹配

                // 栈为空说明没有左括号就来了右括号，不符合规则，失败
                if(stack.isEmpty()){
                    return false;
                }

                // 取出栈顶元素，上面判断了不为空，所以没异常
                char top = stack.pop();

                // 判断栈顶元素是否与目标元素是匹配的，不匹配可以直接返回假了
                if (top == '(' && tag!=')'){
                    return false;
                }else if (top == '[' && tag!=']'){
                    return false;
                }else if (top == '{' && tag!='}'){
                    return false;
                }
            }
        }
        // 最后判断是否还有多的没有匹配的，可以直接返回结果
        return stack.isEmpty();
    }
}