括号匹配问题

括号匹配问题

问题描述：

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

例如：		   "(上海)(长安)"：正确匹配

			 "上海((长安))"：正确匹配 "

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

			 上海(长安))"：错误匹配 "
 
 		   	 ((上海)长安"：错误匹配

示例代码

栈代码

import java.util.Iterator;

public class Stack<T> implements Iterable{
    //记录首结点
    private Node head;
    //栈中元素的个数
    private int N;

    public class Node{
        public T item;
        public Node next;

        public Node(T item,Node next) {
            this.item = item;
            this.next = next;
        }
    }
    //对栈进行初始化
    public Stack() {
        this.head = new Node(null,null);
        this.N = 0;
    }
    //判断当前栈中元素的个数是否为0；
    public boolean isEmpty(){
        return N==0;
    }
    //获取栈中元素的个数
    public int size(){
        return N;
    }
    //把t元素压入栈中
    public void push(T t){
        //找到首结点指向的第一个结点
        Node oldFirst = head.next;
        //创建新结点
        Node newNode = new Node(t, null);
        //再让首结点指向新结点
        head.next = newNode;
        //让新结点指向原来的第一个结点
        newNode.next = oldFirst;
        //元素的个数+1
        N++;
    }
    public T pop() {
        //找到首结点指向的第一个结点
        Node oldFirst = head.next;
        if (oldFirst == null){
            return null;
        }
        //让首结点指向原来第一个结点的下一个结点
        head.next = oldFirst.next;
        //让元素个数-1
        N--;
        return oldFirst.item;
    }

    @Override
    public Iterator iterator() {
        return new SIterator();
    }
    private class SIterator implements Iterator{
        //记录每次遍历拿到的当前结点
        private Node n;

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

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
    //测试代码
        public static void main(String[] args) throws Exception {
            Stack<String> stack = new Stack<>();
            stack.push("a");
            stack.push("b");
            stack.push("c");
            stack.push("d");
            for (Object str : stack) {
                System.out.println(str+" ");
            }
            System.out.println("-----------------------------");
            String result = stack.pop();
            System.out.println("弹出了元素："+result);
            System.out.println("剩余元素个数为"+stack.size());
        }


}

括号匹配代码

import cn.linner.Stack;

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

    //判断str中的括号是否匹配
    public static boolean isMatch(String str){
        //1.创建栈对象，用来存储左括号
        Stack<String> chars = new Stack<>();
        //2.从左往右遍历字符串
        for (int i = 0; i < str.length(); i++) {
            String currChar = str.charAt(i) +" ";

            //3.判断当前字符是否为左括号，如果是，则吧字符放入到栈中
            if (currChar.equals("(")){
                    chars.push(currChar);
            }else  if (currChar.equals(")")){
                //4.继续判断当前字符是否为右括号，如果是，则从栈中弹出一个左括号，并判断弹出的结果是否为null，如果为null证明没有匹配的左括号
                //如果不为null，则证明有匹配的左括号。
                String pop = chars.pop();
                if (pop == null){
                    return false;
                }
            }
        }
        //5.判断栈中是否有剩余的左括号，如果有则证明括号不匹配
        if (chars.size() == 0){
            return true;
        }else {
            return false;
        }
    }
}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){
		return false;
	}	
}