java括号匹配算法求解（用栈实现）

如何使用栈来判定括号是否匹配

对于给定的表达式，可以使用栈来实现括号匹配判定，这个算法在编译器中非常重要，解析器每次读入
一个字符，如果字符是一个开分隔符，如（，【，{，入栈，若读入的是闭分隔符），】，},出栈，如果两者匹配，继续解析字符串，如果不匹配，解析器错误

算法思路

1.创建一个栈
2.当（当前字符不等于输入的结束字符）
（1）如果当前字符不是匹配的字符，判断栈内是否为空，如果栈为空，括号必然不完整
（2）如果字符是一个开分隔符，那么将其入栈
（3）如果字符是一个闭分隔符，，且栈不为空，则判断是否匹配
（4）栈结束后判断是否为空，不为空则括号匹配错误

代码示例

class solution {
  public boolean isvalid(string s) {
    //声明匹配词典
    map<character, character> map = new hashmap<>();
    map.put(')', '(');
    map.put(']', '[');
    map.put('}', '{');
    //创建栈
    stack<character> stack = new stack<>();
    for (char ch : s.tochararray()) {
      //开分隔符入栈
      if (ch == '(' || ch == '[' || ch == '{') {
        stack.push(ch);
      }
      //出栈并且栈非空进行匹配
      else if (stack.isempty() || stack.pop() != map.get(ch)){
        return false;
      }
    }
    //如果栈非空则括号匹配错误
    return stack.isempty();
  }
}

下面是其他同学的补充

1.括号匹配算法

//括号匹配算法
    public void pipei()throws exception{
      char temp,ch;
      int match;  //记录匹配结果
      bufferedreader br = new bufferedreader(new inputstreamreader(system.in));
      ch=(char) br.read();    //输入一个字符
      while(ch!='0'){
        if(gettop()==-1){
          push(ch);
        }else{
          temp=pop();    //取出栈顶元素
          match=0;  //判断是否匹配（默认不匹配）
          if(temp=='('&&ch==')')
            match=1;
          if(temp=='['&&ch==']')
            match=1;
          if(temp=='{'&&ch=='}')
            match=1;
          if(temp=='<'&&ch=='>')
            match=1;
          if(match==0){  //如果不匹配
            push(temp);  //将原栈顶元素重新入栈
            push(ch);  //将输入的括号字符入栈
          }
        }
        ch=(char) br.read();  //输入下一个字符
      }
      if(isempty()){
        system.out.println("输入的括号完全匹配！");
      }else{
        system.out.println("输入的括号不匹配，请检查！");
      }
    }

2.括号匹配求解示例

package com.cn.datastruct;

import java.io.bufferedreader;
import java.io.inputstreamreader;
import java.util.scanner;

public class kuohaopipei {
  static class stack{
    char[] data; //存放数据
    int maxsize;  //最大容量
    int top;    //栈顶指针
    //构造方法
    public stack(int maxsize){
      this.maxsize=maxsize;
      data = new char[maxsize];
      top = -1;
    }

    public int getmaxsize() {
      return maxsize;
    }

    public int gettop() {
      return top;
    }

    public boolean isempty(){
      return top==-1;
    }
    
    public boolean isfull(){
      return top+1==maxsize;
    }
    //入栈
    public boolean push(char data){
      if(isfull()){
        system.out.println("栈已满!");
        return false;
      }
      this.data[++top]=data;
      return true;
    }
    //出栈
    public char pop() throws exception{
      if(isempty()){
        throw new exception("栈已空！");
      }
      return this.data[top--];
    }    
    //获得栈顶元素
    public char peek(){
      return this.data[gettop()];
    }
    
    //括号匹配算法
    public void pipei()throws exception{
      char temp,ch;
      int match;  //记录匹配结果
      bufferedreader br = new bufferedreader(new inputstreamreader(system.in));
      ch=(char) br.read();    //输入一个字符
      while(ch!='0'){
        if(gettop()==-1){
          push(ch);
        }else{
          temp=pop();    //取出栈顶元素
          match=0;  //判断是否匹配（默认不匹配）
          if(temp=='('&&ch==')')
            match=1;
          if(temp=='['&&ch==']')
            match=1;
          if(temp=='{'&&ch=='}')
            match=1;
          if(temp=='<'&&ch=='>')
            match=1;
          if(match==0){  //如果不匹配
            push(temp);  //将原栈顶元素重新入栈
            push(ch);  //将输入的括号字符入栈
          }
        }
        ch=(char) br.read();  //输入下一个字符
      }
      if(isempty()){
        system.out.println("输入的括号完全匹配！");
      }else{
        system.out.println("输入的括号不匹配，请检查！");
      }
    }
  }
  
  public static void main(string[] args) throws exception {
    string go;
    scanner input = new scanner(system.in);
    stack stack = new stack(20);
    system.out.println("括号匹配问题！");
    do{
      system.out.println("请输入一组括号的组合，以0表示结束。支持的括号包括：{},(),[],<>。");
      stack.pipei();    //匹配算法
      system.out.print("\n继续匹配吗（y/n）?");
      go=input.next();
    }while(go.equalsignorecase("y"));
    system.out.println("匹配结束！");
  }

}

程序运行结果如下：

括号匹配问题！
请输入一组括号的组合，以0表示结束。支持的括号包括：{},(),[],<>。
({[]})<>0
输入的括号完全匹配！

继续匹配吗（y/n）?y
请输入一组括号的组合，以0表示结束。支持的括号包括：{},(),[],<>。
({])0
输入的括号不匹配，请检查！

继续匹配吗（y/n）?n
匹配结束！

补充2

#include <cstdio>
#include <iostream>
using namespace std;
 
#define maxsize 20
 
typedef struct {
	char *base;
	char *top;
	int stacksize;
}sqstack;
 
void initstack(sqstack &s)
{
	s.base = (char *)malloc( maxsize * sizeof(char) );
	if(s.base == null)	exit(-2);
	s.top = s.base;
	s.stacksize = maxsize;
}
 
void gettop(sqstack s, char &e)
{
	if(s.top == s.base)
		return;
	e = *(s.top - 1);
}
 
void push(sqstack &s, char e)							//	不考虑栈满
{
	*s.top++ = e;
}
 
void pop(sqstack &s, char &e)
{
	if(s.top == s.base)
		return;
	s.top--;
	e = *s.top;
}
 
bool match(char c, sqstack &my_stack, bool &tag)
{
	char e;
	pop(my_stack, e);
	if ( c != e ) {
		tag = false;
		free(my_stack.base);
		return false;									//	match fail
	}
	return true;										//	match success
}
 
void correct(char *expr, bool &tag)
{
	tag = true;	
	sqstack my_stack;
	initstack (my_stack);
	for( int i = 0; expr[i] != '\0'; i++ ) {
		char c = expr[i];
		switch(c) {
			
		case '{' : case '[' : case '(' :
			push (my_stack, c); break;
			
		case '}' : 
			if( match('{', my_stack, tag) == false )	//	match fail
				return;
			break;
			
		case ']' : 
			if( match('[', my_stack, tag) == false )	//	match fail
				return;
			break;
			
		case ')' : 
			if( match('(', my_stack, tag) == false )	//	match fail
				return;
			break;
			
		default :
			break;										//	其它字符
		}
	}
	if(my_stack.top != my_stack.base)					// e.g.: "[r"
		tag = false;
	free(my_stack.base);
}
 
int main(void)
{
	//	freopen("cin.txt", "r", stdin);
	char my_expr[maxsize];
	while(cin >> my_expr) {
		bool tag = true;
		correct( my_expr, tag);
		tag ? printf("匹配成功\n") : printf("匹配失败\n");
	}
	
	return 0;
}

到此这篇关于java括号匹配算法求解（用栈实现）的文章就介绍到这了,更多相关java括号匹配算法内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！