数据结构与算法-使用栈《解决括号匹配问题》

问题描述

    给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。 
例如： 
    "(上海)(长安)"：正确匹配 
    "上海((长安))"：正确匹配 
    "上海(长安(北京)(深圳)南京)":正确匹配 
    "上海(长安))"：错误匹配 
    "((上海)长安"：错误匹配

代码如下

输出结果

(北京(上海)()) 括号匹配是否正确：true

测试代码

public class T1{
    public static void main(String[] args) {
        String str = "(北京(上海)())";
        System.out.println("(北京(上海)()) 括号匹配是否正确：" + caculate(str));
    }
    /**
     *
     * @param str
     * @return
     */
    public static boolean caculate(String str) {
        //1.创建栈对象，用来存储左括号
        Stack<String> sta = new Stack<>();
        //2.从左往右遍历字符串
        for (int i = 0; i < str.length(); i++) {
            String curr = str.charAt(i) + "";
            //3.判断当前字符是否为左括号，如果是，则把字符添加到栈中
            if (curr.equals("(")) {
                sta.push(curr);
            } else if (curr.equals(")")) {
                //4.判断当前字符是否为右括号，如果是，则从栈中弹出一个元素，并判断弹出的元素是否为null，
                //4.如果为null 证明没有匹配的左括号，如果不为null，证明有匹配的左括号
                String pop = sta.pop();
                if (pop == null) {
                    return false;
                }
            }
        }
        //遍历完毕之后判断，栈中还有没有的元素，如果有则证明括号不匹配
        return sta.size() == 0;
    }
}

自定义栈代码

package cn.bloghut.linear;

import java.util.Iterator;

/**
 * @author by 闲言
 * @classname Stack
 * @description 模拟栈API
 * @date 2021/7/17 22:48
 */
public class Stack<T> implements Iterable<T> {
    //定义都结点
    private Node head;
    //定义栈中元素个数
    private int size;


    public class Node {
        //存储内容
        private T item;
        //存储下一个结点信息
        private Node next;

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

    //初始化数据
    public Stack() {
        this.head = new Node(null, null);
        this.size = 0;
    }

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

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

    /**
     * 把元素t压栈
     *
     * @param t
     */
    public void push(T t) {
        //创建新结点
        Node newNode = new Node(t, null);
        //获取首节点的第一个结点
        Node oldNode = head.next;
        //让首节点重新指向 新插入的结点
        head.next = newNode;
        //让新结点指向原来的第一个结点
        newNode.next = oldNode;
        //元素个数+1
        size++;
    }

    /**
     * 弹出栈顶元素
     */
    public T pop() {
        //获取头结点指向的第一个结点
        Node popNode = head.next;
        if (popNode == null) {
            return null;
        }
        //让收结点指向 原来第一个结点的下一个结点
        head.next = popNode.next;
        //元素个数减1
        size--;
        return popNode.item;
    }

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

    public class MyIterator implements Iterator {

        private Node node;

        public MyIterator() {
            this.node = head;
        }

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

        @Override
        public Object next() {
            node = node.next;
            return node.item;
        }
    }
}