栈

栈

​ 栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。

我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。

/**
 * 栈--单链表实现（头结点位置是栈顶）
 */
public class Stack<T> implements Iterable<T> {
    // 记录首结点
    private Node head;
    // 栈中元素的个数
    private int N;

    public Stack() {
        this.head = new Node(null, null);
        this.N = 0;
    }

    // 判断当前栈中元素个数是否为0
    public boolean idEmpty() {
        return N == 0;
    }

    // 获取栈中元素的个数
    public int size() {
        return N;
    }

    // 把t元素压入栈
    public void push(T t) {
        // 创建新结点，保存数据，并让新节点指向原来的第一个结点
        Node node = new Node(t, head.next);
        // 首结点指向新结点
        head.next = node;
        // 元素个数+1
        N++;
    }

    // 弹出栈顶元素
    public T pop() {
        // 安全校验  判断是否为空栈
        if (head.next == null) {
            return null;
        }
        // 找到首结点指向的第一个结点
        Node oldFirst = head.next;
        // 让首结点指向原先的第一个结点的下一个结点
        head.next = oldFirst.next;
        // 元素个数-1
        N--;
        return oldFirst.item;
    }

    @Override
    public Iterator<T> iterator() {
        return new SIterator();
    }

    private class SIterator implements Iterator<T> {
        private Node n;

        public SIterator() {
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public T next() {
            n = n.next;
            return n.item;
        }
    }

    private class Node {
        private T item;
        private Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
}

案例：括号匹配问题

问题描述：

给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。

例如：

“(上海)(长安)”：正确匹配

“上海((长安))”：正确匹配

“上海(长安(北京)(深圳)南京)”:正确匹配

“上海(长安))”：错误匹配

“((上海)长安”：错误匹配

分析：

1.创建一个栈用来存储左括号

2.从左往右遍历字符串，拿到每一个字符

3.判断该字符是不是左括号，如果是，放入栈中存储

4.判断该字符是不是右括号，如果不是，继续下一次循环

5.如果该字符是右括号，则从栈中弹出一个元素t；

6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号

7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配

代码实现：

public class BracketsMatch {
    public static void main(String[] args) {
        String str = "(上海(长安)())";
        boolean match = isMatch(str);
        System.out.println(str + "中的括号是否匹配：" + match);
    }

    /**
     * 判断str中的括号是否匹配
     *
     * @param str 括号组成的字符串
     * @return 如果匹配，返回true，如果不匹配，返回false
     */
    public static boolean isMatch(String str) {
        // 创建栈对象，用来存储左括号
        Stack<String> chars = new Stack<>();
        // 从左往右遍历字符串
        for (int i = 0; i < str.length(); i++) {
            // 判断当前字符是否为左括号，是，字符压栈
            String currChar = str.charAt(i) + "";
            if ("(".equals(currChar)) {
                chars.push(currChar);
            } else if (")".equals(currChar)) {
                // 不是左括号，判断当前字符是否为右括号。是，对栈进行弹栈，判断弹栈结果，如果为空，没有匹配的左括号，返回false，不为空，右匹配的左括号
                String pop = chars.pop();
                if (pop == null) {
                    return false;
                }
            }
        }
        // 遍历完毕，判断栈是否为空，不为空剩余左括号，证明括号不匹配
        if (chars.idEmpty()) {
            return true;
        } else {
            return false;
        }
    }
}