栈的应用—分隔符匹配

例二、分隔符匹配问题

1、问题描述

编译器在编译一段代码时,首先进行的就是分隔符的匹配,常见的分隔符有{   } [   ]  (   )/*  */

2、思路

首先要知道的一件事就是:分隔符运行嵌套,而且,读入的顺序和处理的顺序相反,很显然是用栈。

算法描述如下: 从左到右扫描java语句,从语句中不断的读取字符,每次读取一个字符,若发现它是左分割符,则将它压入栈;

当从输入中读到一个右分割符时,则弹出栈顶 的左分隔符,并且查看它是否和右分隔符匹配,若它们不匹配,则匹配失败,程序报错;

若栈顶没有左分隔符与右分隔符匹配,或者一直存在没有被匹配的左分隔符,左分隔符没有被匹配,表现为所有的字符都读入后,栈中仍然有左分隔符,则匹配失败,程序报错;

若所有的字符读入结束后,栈为空,则表示匹配成功

3、代码实现

package org.Stone6762.MStack.adopt;  
  
import java.util.Scanner;  
  
import org.Stone6762.MStack.imple.SeqStack;  
  
/** 
 * @author_Stone6762 
 */  
public class MatchTest {  
  
    /** 
     * @LEFT记录分隔符为“左”分隔符 
     */  
    private final int LEFT = 0;  
  
    /** 
     * @RIGHT记录分隔符为“右”分隔符 
     */  
    private final int RIGHT = 1;  
  
    /** 
     * @OTHER记录其他字符 
     */  
    private final int OTHER = 2;  
  
    /** 
     * @MAXSIZE栈的大小_也就是整个程序中的左分隔符的个数的最大值 
     */  
    private final int MAXSIZE = 100;  
  
    /** 
     * @Describe_判断分隔符的类型_左_右_非法 
     * @param str 
     * @return 
     */  
    public int verifyFlag(String str) {  
        if ("(".equals(str) || "[".equals(str) || "{".equals(str)  
                || "/*".equals(str)) {  
            return LEFT;  
        } else if (")".equals(str) || "]".equals(str) || "}".equals(str)  
                || "*/".equals(str)) {  
            return RIGHT;  
        } else {  
            return OTHER;  
  
        }  
  
    }  
  
    /** 
     * @Describe_判断左分隔符str1和右分隔符str2是否匹配 
     * @param str1 
     * @param str2 
     * @return 
     */  
    public boolean matches(String str1, String str2) {  
        if (("(".equals(str1) && ")".equals(str2))  
                || ("{".equals(str1) && "}".equals(str2))  
                || ("[".equals(str1) && "]".equals(str2))  
                || ("/*".equals(str1) && "*/".equals(str2))) {  
            return true;  
        } else {  
            return false;  
        }  
    }  
  
    /** 
     * @Describe_判断是否匹配 
     * @param str 
     * @return 
     * @throws Exception 
     */  
    public boolean isLegal(String str) throws Exception {  
        if (!"".equals(str) && str != null) {  
            SeqStack S = new SeqStack(MAXSIZE);  
            int length = str.length();  
            for (int i = 0; i < length; i++) {  
                // 取出元素  
                char c = str.charAt(i);  
                String t = String.valueOf(c);  
  
                // 对 分隔符/**/特别处理  
                if (i != length) {  
                    if ((‘/‘ == c && ‘*‘ == str.charAt(i + 1))  
                            || (‘*‘ == c && ‘/‘ == str.charAt(i + 1))) {  
                        t = t.concat(String.valueOf(str.charAt(i + 1)));  
                        i++;  
                    }  
                }  
                // 如果是左分隔符,入栈,如果是右分隔符,出栈,看是否匹配,如果不匹配,报错  
                if (LEFT == verifyFlag(t)) {  
                    S.push(t);  
                } else if (RIGHT == verifyFlag(t)) {  
                    if (S.isEmpty()) {  
                        throw new Exception("错误:   java语法不合法,缺少左分隔符");  
                    } else if (!matches(S.pop().toString(), t)) {  
                        throw new Exception("错误:   java语法不合法,左右分隔符不匹配");  
                    }  
                }  
            }  
            // 对整个语句遍历后,如果栈非空,证明栈中还有未被匹配的左分隔符,此时是错误的  
            if (!S.isEmpty()) {  
                throw new Exception("错误: java语句不合法,缺少右分隔符");  
            } else {  
                return true;  
            }  
        } else {  
            throw new Exception("错误:Java语句为空 ! ");  
        }  
    }  
  
    public static void main(String[] args) throws Exception {  
        MatchTest m = new MatchTest();  
        Scanner scan = new Scanner(System.in);  
        System.out.println("请输入 想要判断 java语句");  
        while (scan.hasNext()) {  
            if (m.isLegal(scan.nextLine())) {  
                System.out.println("Java语句正确");  
            } else {  
                System.out.println("错误:Java语句不合法");  
            }  
            System.out.println();  
            System.out.println("请输入 想要判断 java语句");  
        }  
    }  
}

时间: 2024-08-07 00:13:23

栈的应用—分隔符匹配的相关文章

栈2--括号的匹配

栈2--括号的匹配 一.心得 二.题目及分析 有(和),如果匹配输出1,如果不匹配输出0. 三.代码及结果 1 #include <iostream> 2 using namespace std; 3 4 bool judge(char c[256]){ 5 int top=0; 6 int i=0; 7 while(c[i]!='@'){ 8 if(c[i]=='(') top++; 9 if(c[i]==')'){ 10 if(top>0) top--; 11 else return

C数据结构-栈和队列,括号匹配举例

1.栈和队列是两种特殊的线性表 运算操作被限定只能在表的一端或两端插入,删除元素,故也称它们为限定的线性表结构 2.栈的基本运算 1).Stackinit(&s) 构造一个空栈 2).Stackempty(s) 判断s是否为空栈,当s为空栈时,函数返回值1 否则 0 3).Push(&s,x)  在栈s 的顶部插入元素x,简称将x入 栈 4).Pop(&s,&x) 在栈s 中删除顶元并将其值保存在x单元中返回,简称将x出栈 5)Gettop(s,&x)  读s栈中的

[栈和队列]括号匹配

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 #define INIT_STACK_SIZE 100 5 typedef struct 6 { 7 char * chOperator; 8 int dwtop; 9 }OPND; 10 11 void InitStack(OPND *); 12 char Pop(OPND *); 13 void Push(OPND *,char );

leetcode题解:Valid Parentheses(栈的应用-括号匹配)

题目: Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid. The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]&

【数据结构】用栈检测括号是否匹配

//[数据结构]用栈检测括号是否匹配 //头文件 栈 #ifndef _STACK_ #define _STACK_ #include <iostream> #include <string.h> using namespace std; template <class Type> class Stack { public: Stack(size_t sz = INIT_SIZE) { capacity = sz > INIT_SIZE ? sz : INIT_S

数据结构实验之栈四:括号匹配(栈)

数据结构实验之栈四:括号匹配 Time Limit: 1000ms   Memory limit: 65536K  有疑问?点这里^_^ 题目描述 给你一串字符,不超过50个字符,可能包括括号.数字.字母.标点符号.空格,你的任务是检查这一串字符中的( ) ,[ ],{ }是否匹配. 输入 输入数据有多组,处理到文件结束. 输出 如果匹配就输出"yes",不匹配输出"no" 示例输入 sin(20+10) {[}] 示例输出 yes no 提示 来源 ma6174

栈应用之括号匹配

栈的使用之括号匹配 Char s[n]是一个字符串数组.Stack是一栈,i是元素对应的下表.设一个char flag[n]数组,用来标记是否匹配,数组中数值是‘l’(左不匹配,即没有找到右括号),‘r’(右不匹配),‘o’匹配成功. 算法描述: (1)遍历该字符串数组. While(遍历){ if遇到‘(’,do stack.push(i)(i 是‘(’对应的数组下表),flag[i]=’o’(不一定就是匹配成功,以后遍历完如果stack还有元素,说明没有左匹配,要改成‘l’:如果没有,则就是

栈应用之 括号匹配问题(Python 版)

栈应用之 括号匹配问题(Python 版) 检查括号是否闭合 循序扫描被检查正文(一个字符)里的一个个字符 检查中跳过无关字符(所有非括号字符都与当前处理无关) 遇到开括号将其压入栈 遇到闭括号时弹出当时的栈顶元素与之匹配 如果匹配成功则继续,发现匹配失败时则以检查失败结束 1 def check_parens(text) : 2 # 括号匹配检查函数,text 是被检查的正文串 3 parens = "(){}[]" 4 open_parens = "({[" 5

POJ 题目3415 Common Substrings(后缀数组+栈,求可以匹配到的长度大于k的公共子串个数)

Common Substrings Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 8471   Accepted: 2798 Description A substring of a string T is defined as: T(i, k)=TiTi+1...Ti+k-1, 1≤i≤i+k-1≤|T|. Given two strings A, B and one integer K, we define S, a