看看编译原理吧...

"看看编译原理吧..."

呵呵，你这是个好方法，但是我很着急啊，从头学编译原理恐怕来不及了呀？

大伙帮帮忙，谢谢啦

这是东北大学2004年硕士研究生考试的一道考题，15分，估计不是很复杂，但是就是没有思路，
恨死我了，


我用堆栈方式，能做到题目要求的匹配，但是是循环，不是递归，

const char *next_token(const char *s){
   while(*s!='\0'&&*s!='['&&*s!=']'&&*s!='('&&*s!=')'&&*s!='{'&&*s!='}')s++;
   return s;
}
const char *IsRecurMatch(const char *string){
    char cur_char = -1;    
    const char *next;
    string = next_token(string);
    switch(*string){
    case '(':
    case '[':
    case '{':
        cur_char = *string;
        next = IsRecurMatch(string+1); 
        if(next == NULL)return NULL;
        if(*next!=cur_char)return NULL;
        next++;
        next = next_token(next);
        break;
    case ')':
    case ']':
    case '{':
        return string;
    }
    return NULL;
}

BOOL Is_Match(const char *string){
    return IsRecurMatch(string)!=NULL;
}

我以前写的程序的一小部分，
你看看能否用到（词法分析）

/* 获取新的标号 */

TokenType
getToken(void)
{
int tokIdx = 0;
TokenType curTok;
StateType state = START;
int save;
while (state != DONE) {
int c = nextChar(TRUE);
save = TRUE;
switch(state) {
case START:
if(isdigit(c))
state = INNUM;
else if (isalpha(c))
state = INID;
else if (c == ':')
state = INASSIGN;
else if ((c == ' ') || (c == '\t') || (c == '\n'))
save = FALSE;
else if (c == '{') {
save = FALSE;
state = INCOMMENT;
}else {
state = DONE;
switch(c) {
case EOF:
save = FALSE;
curTok = ENDFILE;
break;
case '=':
curTok = EQ;
break;
case '<':
curTok = LT;
break;
case '+':
curTok = PLUS;
break;
case '-':
curTok = MINUS;
break;
case '*':
curTok = TIMES;
break;
case '/':
curTok = OVER;
break;
case '(':
curTok = LPAREN;
break;
case ')':
curTok = RPAREN;
break;
case ';':
curTok = SEMI;
break;
default:
curTok = ERROR;
break;
}
}
break;
case INCOMMENT:
save = FALSE;
if(c == EOF) {
state = DONE;
curTok = ENDFILE;
}else if(c == '}') state = START;
break;
case INASSIGN:
state = DONE;
if(c == '=')
curTok = ASSIGN;
else {
nextChar(FALSE);
save = FALSE;
curTok = ERROR;
}
break;
case INNUM:
if (!isdigit(c)) {
nextChar(FALSE);
save = FALSE;
state = DONE;
curTok = NUM;
}
break;
case INID:
if(!isalpha(c)) {
nextChar(FALSE);
save = FALSE;
state = DONE;
curTok = ID;
}
break;
case DONE:
default:
fprintf(listing,"扫描错误: 状态= %d\n",state);
state = DONE;
curTok = ERROR;
break;
}
if(save && tokIdx <= NELEMS(tokStr))
tokStr[tokIdx++] = (char)c;
if (state == DONE) { tokStr[tokIdx] = '\0';
if (curTok == ID) curTok = tok_lookup(tokStr);
}
}
fprintf(listing, "\t%d: ", line);
printToken(curTok, tokStr);
return curTok;
}

方正国际笔试题

搞的那么复杂干吗!
为大,中，小括号各设一个变量，初始为0
读串，遇左括号加一，右减一
满足以下两个条件匹配：
1，过程中，每个变量大于等于0
2，最后都归0。

上个月我们学校编程大赛有类似题，我就靠这个得了第一。

数据结构的时候用栈的先进后出机制实现的！

xhute(AAA)，
你那方法解决不了括号交叉的情况吧，象{[}]。:)

肯定是用堆栈了，见到左括号，就如栈，同样遇到右括号，就把栈顶和左括号比较，如果是对应的就出栈，否则不动，处理完成，如果堆栈的元素个数大于0，就不匹配。

搞的那么复杂干吗!
为大,中，小括号各设一个变量，初始为0
读串，遇左括号加一，右减一
满足以下两个条件匹配：
1，过程中，每个变量大于等于0
2，最后都归0。

上个月我们学校编程大赛有类似题，我就靠这个得了第一。

你们什么大学啊？  这样的结果也能得第一？

堆可以用数组模拟一下 放一个指针指一下就可以路

使用栈ADT

不需要学习编译原理的。
以下代码用delphi扫描表达式字符串中的（）是否匹配，Ｃ＋＋和其他括号类似：
var
  zgh,ygh,i:integer;
  str:string;
begin
  zgh:=0;ygh:=0;
　for i:=1 to Length(str) do
  begin
    ch:= str[i];
    if ch='(' then
       Inc(zgh);
    else if ch=')' then
       Inc(ygh);
    end
  end;
  if zgh<>ygh then
    ShowMessage('括号不匹配');
end;

我的方法确实处理不了括号交叉问题,刚才急着去吃饭没多想.SORRY

我们比赛题中有一个题用到了一点这方面的思想而已

用栈实现也不难.

不错不错！

找到第一个( 或者{/[ 然后再从串最后开始找最匹配的) 或者}/]  找到之后 ,取它两个中间的串进行递归调用!! 嘿嘿

#include<windows.h>
#include<stdio.h>

#define FAIL   -1
#define SUCCESS 0

char *next_token(char *s)
{
   while(*s!='\0'&&*s!='['&&*s!=']'&&*s!='('&&*s!=')'&&*s!='{'&&*s!='}')
   s++;
   return s;
}

char UnChange(char *s ) 
{
   switch( *s )
   {
   case '(':
   return ')';
   
   case ')':
   return '(';

   case '[':
   return ']';

   case ']':
   return '[';

   case '{':
   return '}';

   case '}':
   return '{';


   default:
   return *s;
   }
}



char* IsRecurMatch(char *string)
{
static int iCount = 0;
char  cCurChar;
    char  *cur_char = NULL;    
    char  *pcNext   = NULL;
    
    cur_char = next_token(string);
    switch(*cur_char)
{
    case '(':
    case '[':
    case '{':
cCurChar = UnChange(cur_char);
        pcNext   = IsRecurMatch(cur_char+1); 
if( pcNext == '\0' )
{
   return pcNext;
}
if( cCurChar == *pcNext )
{
   //printf("字符%c匹配成功!\n", cCurChar);
   pcNext = next_token(pcNext+1);
   return pcNext;
}
else
{
   printf("错误：字符%c匹配失败: %c != %c\n", *pcNext, UnChange(&cCurChar), *pcNext);
   exit(1);
}

    case ')':
    case ']':
    case '}':
        return cur_char;

default:
return cur_char;
    }  
}

int Is_Match(char *string)
{   
static int iCount = 0;
char *cTemp = IsRecurMatch(string);

iCount ++;

switch(*cTemp)
{
case ')':
case '}':
case ']':
{
   if( iCount == 0 )
   {
      printf("错误：算术表达式不能以 %c 开头\n", *cTemp);
      exit(1);
   }
   else
   {
              printf("错误：算术表达式 %c 无法匹配\n", *cTemp);
      exit(1);
   }
}

case '(':
case '[':
case '{':
        Is_Match(cTemp);
break;

case '\0':
return 0;

    default:
printf("不知道的错误!");
exit(1);
}
    
}

void main()
{   
int iRet = Is_Match("{1klk}");
if( iRet == 0 )
{
       printf("成功！\n");
}
else
{
   printf("失败！\n");
}
}
四楼的程序改一下就好了!

mark!

java程序，给分吧
package test;

import java.util.*;
public class Test {
    public String text="fewe{f(sdd(f)a[j]sdk)j}f";
    int i=0;
    public LinkedList stack=new LinkedList();
    public Test() {
    }
    public String analyiz(int ip){
       char temp=text.charAt(ip);
       char a;
       if(temp=='('||temp=='['||temp=='{'){
           stack.add(temp);
       }else if(temp==')'){
           a=(Character)stack.getLast();
           if(a=='('){
              stack.removeLast();
           }
       }else if(temp==']'){
           a=(Character)stack.getLast();
           if(a=='['){
              stack.removeLast();
           }
       }else if(temp=='}'){
           a=(Character)stack.getLast();
           if(a=='{'){
              stack.removeLast();
           }           
       }
       if(stack.size()==0&&ip==text.length()-1){
           String c="匹配";
           return c;
       }else if(stack.size()!=0&&ip==text.length()-1){
           String b="不匹配";
           return b;
       }else{
           return analyiz(ip+1);
       }
    }
    public static void main(String[] args){
        Test test=new Test();
        String a=test.analyiz(0);
        System.out.println(a);
    }
}

char *s="{([";
 结束递归的条件：如果*s='\0';
           return true;
否则：
k1=0;k2=0;k=0 计数器清0
for(*p=str,;p!='\0';p++)
   if(*p==*s)
     k1++;
  if(*p==reverse(*s))
    k2++;

for(*p=s,*q=strlen(str)-1;q>=s;p++,q--)
  if(*p==reverse(*q)&&*(p+1)不属于"])"&&*(q-1)不属于"[(";)//不属于可以用个函数实现,rerverse 是该符号的反转字符
   K++;
  if(K*2==K1+K2)
    调用递归将s变为s+1;
  else return false
 
}

//  来个短点的,理解起来方便一些
#include <vector>
using namespace std;


bool isMatch(const char* pStr)
{
    const char* p = NULL;
    p = pStr;

    vector<char> Stack;

    while(*p)
    {
        if (   (*p != '{') && (*p != '}') 
            && (*p != '[') && (*p == ']') 
            && (*p != '(') && (*p != ')')
           )
        {
            if (Stack.empty())
            {
                return (false);
            }
            p++;
        }
        else if ((*p == '{') && (*p != '[') && (*p != '('))
        {
            Stack.push_back(*p);
            p++;
        }
        else if ((*p == '}') && (*p != ']') && (*p != ')'))
        {
            char c = '\0';
            if (Stack.empty())
            {
                return (false);
            }
            
            c = Stack[Stack.size() - 1];        
            if (   ('{' == c) && (*p == '}') 
                || ('[' == c) && (*p == ']') 
                || ('(' == c) && (*p == ')') 
               )
            {
                Stack.pop_back();
                p++;
                continue;
            }

            return (false);
        }
    }

    return (Stack.empty());
}


int main()
{
    const char *p = "{}";
    
    printf("%s\n", isMatch(p)? "True": "False");

    getchar();
}

我写一个简明的
bool ismatch(const char *&cp, char ch_wanted){ 
    if(!*cp)
        return !ch_wanted;    
    bool f = false;
    char ch = *cp++;
    switch(ch){
        case '(':
            f = ismatch(cp,')');
            break;
        case '[':
            f = ismatch(cp,']');
            break;
        case '{':
            f = ismatch(cp,'}');
            break;
        default:
            f = (ch == ch_wanted);
    }
        
    return f && ismatch(cp,'\0');
}
int main(){
    const char* p = "())";
    cout<<ismatch(p,'\0')<<endl;
    cin.get();
    return 0;
}

堆栈~~~
{ 入
}出

写的比较粗糙，基本能满足要求
void ismatch(char *str);
void push(char ch);
void pop(char ch);
bool isilleg(char ch);
bool flag=false;
char stak[512];
int point=0;

int _tmain(int argc, _TCHAR* argv[])
{
char str[512];
gets(str);
while(*str!='\0')
{
ismatch(str);
if(point!=0 || flag)
printf("wrong");
else
printf("right\n");
gets(str);
    flag=false;
    point=0;
 
}
return 0;
}

void ismatch(char *str)
{
if(flag)
return;
char tmp = *str;
switch(tmp)
{
case '\0':
return;
case '{':
case '[':
case '(':
if(isilleg(tmp))
return;
push(tmp);
break;
case '}':
case ']':
case ')':
pop(tmp);
break;
default:
    break;
}
str++;
ismatch(str);
}

void push(char ch)
{ 
if(flag)
return;
stak[point++]=ch;
}

void pop(char ch)
{
switch(ch)
{
case '}':
if(stak[--point]=='{')
stak[point]='\0';
else
{
point++;
push(ch);
point++;
}
break;
case ']':
         if(stak[--point]=='[')
stak[point]='\0';
else
{
point++;
push(ch);
point++;
}
break;
case ')':
         if(stak[--point]=='(')
stak[point]='\0';
else
{
point++;
push(ch);
point++;
}
break;
default:
break;
}
}

bool isilleg(char ch)
{
if (point==0)
return flag;
int i=point-1;
switch(ch)
{
case '{':
if(stak[i]=='['|| stak[i]=='(')
flag=true;
break;
    case '[':
if(stak[i]=='(')
flag=true;
break;
default:
break;
}
return flag;
}

学习那~~
嘿嘿~~

这就是经典的“期待的急迫程度”例子。设置一个栈就可以轻松解决。

mark

好久没用C，差不多不会写了，下面是个用java写的程序。

public class Test{
    public static void main(String[] args) {

        //测试用字符串
        String st = "asdfd{adf{sd}(dd)[}adsf]sdf({})"; 

        //使用正则表达式，将所有非()[]{}字符替换为空，相当于删除
        st = st.replaceAll("[^\\(\\)\\{\\}\\[\\]]",""); 

        //判断是否包含成对出现的()[]{}
        while(st.indexOf("[]")>=0 || st.indexOf("()")>=0 || st.indexOf("{}")>=0){
            //如果有，则用正则表达式将成对出现的()[]{}替换为空
            st = st.replaceAll("\\[\\]|\\(\\)|\\{\\}","");                        
        }

        //输出判断结果，长度为0代表所有括号均为成对出现
        System.out.println(st.length() == 0); 
    }
}

#include <stdio.h>
#include <iostream>
#include <string>
using namespace std;
typedef string::size_type spos;

spos minpos(spos sp1,spos sp2,spos sp3)//这里写的不好
{
    string::size_type ipos1=string::npos-sp1,ipos2=string::npos-sp2,ipos3=string::npos-sp3;
return string::npos-((ipos1>ipos2?ipos1:ipos2)>ipos3?(ipos1>ipos2?ipos1:ipos2):ipos3);
}

int is_match(string str) //-1表示不匹配，0表示匹配
{
string::size_type ipos1,ipos2,ipos3,ircal,ilcal;
char s;
    ipos1=str.find_first_of('}');
ipos2=str.find_first_of(']');
ipos3=str.find_first_of(')');
    ircal=minpos(ipos1,ipos2,ipos3);//找位置最左边的先处理
if (ircal==ipos1) s='{';
else if (ircal==ipos2) s='[';
else if (ircal==ipos3) s='(';
ilcal = str.find_first_of(s);
if ((ilcal==string::npos)&&(ircal!=string::npos)) 
return -1;
else
    if ((ilcal!=string::npos)&&(ircal==string::npos))
return -1;
    else
    if ((ilcal==string::npos)&&(ircal==string::npos)) 
return 0;
    else
if (ilcal>ircal) return -1;
else 
{
   str.erase(ilcal,ircal-ilcal+1);
   //cout <<str<<endl;
       return is_match(str);
}
    
}


void main ()
{
string s;
cin>>s;
cout<<is_match(s);
}

以上只能判断括号匹配问题，对于字符串中含有+）之类的就无能为力了！

不错,学习!

请看鄙人的<< 正则表达式30分钟入门教程(第二版)>>(http://www.unibetter.com/deerchao/zhengzhe-biaodashi-jiaocheng-se.htm)里关于"平衡组"的介绍.

说明:适用于.net framework. 不过其它环境下的Regex实现好像也有支持平衡组的,不过语法不同.

typedef char StackEntry;
            int Check( )
            {
             STACK S;        //定义栈结构S
             char ch;
 InitStack(&S);      //初始化栈S
while ((ch=getchar())!=’\n’) {   
//以字符序列的形式输入表达式
  switch (ch) {
   case (ch==‘(’||ch== ‘[’||ch== ‘{’): Push(&S,ch);break;  //遇左括号入栈
   //在遇到右括号时，分别检测匹配情况
case (ch== ‘)’): if (StackEmpty(S)) retrun FALSE;     
                else {Pop(&S,&ch);
                     if (ch!= ‘(’) return FALSE; }
                break;
case (ch== ‘]’): if (StackEmpty(S)) retrun FALSE;
                else {Pop(&S,&ch);
if (ch!= ‘[’) return FALSE;  }
                break;
   case (ch== ‘}’): if (StackEmpty(S)) retrun FALSE;
                else {Pop(&S,&ch);
                     if (ch!= ‘{’) return FALSE;  }
                break;
   default:break;
  }
 }
 if (StackEmpty(S)) return TRUE;
  else return FALSE;
}

来晚鸟。木由分。

xhute(AAA)，
搞的那么复杂干吗!
为大,中，小括号各设一个变量，初始为0
读串，遇左括号加一，右减一
满足以下两个条件匹配：
1，过程中，每个变量大于等于0
2，最后都归0。
------------------------------------------------
這個只能判斷非常簡單的問題!真不明白這個也能得獎，一句話‘不實用’；
如果要判斷非常復雜的SQL語句就肯定不行！
我以前也做過類似的問題(當時是用存儲過程寫的)
1、先紀錄下各個符號的位置
2、再做相應的匹配處理
3、再根據匹配的方法分解SQL語句

进栈,出栈

mark

mark

检查表达式括号匹配问题

注：文中的“位置不存在”指按指定的规则没有搜索到目标，通常编程中用特殊数值表示该情况，以区分正常的位置数值。

递归方案
处理STEP如下：
1． 从左至右搜索第一次出现的“(,[,{”，记为位置1。
2． 从右至左搜索第一次出现的“),],}”，记为位置2。
3． 如果位置1和位置2都不存在，则返回OK。
4． 如果位置1和位置2只有一个存在，则返回ERROR。
5． 如果位置1>位置2，则返回ERROR。
6． 如果位置1和位置2对应的左右括号不配对，则返回ERROR。
7． 递归处理位置1和位置2包围的中间字符串。

非递归方案（堆栈方案）
处理STEP如下：
1． 记位置1为0，初始化堆栈为空。
2． 从表达式位置1开始向右搜索“(,),[,],{,}”，记为位置1。
3． 如果位置1不存在，且堆栈为空，则返回OK。
4． 如果位置1不存在，且堆栈不为空，则返回ERROR。
5． 如果位置1是“(,[,{”，则将位置1的括号压入堆栈，goto Step2。
6． 如果位置1是“),],}”，则从堆栈弹出括号。
7． 如果堆栈弹出失败（堆栈为空），则返回ERROR。
8． 如果弹出括号和位置1的括号不配对，则返回ERROR。
9． 位置1加1，Goto Step2。

有问题请各位指正，共同学习，谢谢。
个人认为程序用什么写不重要，重要的是解决问题的方案。

biqiweish()说的有道理

后进先出堆栈，遇到“（”时进栈，“）”时出栈，如果到最后栈空了就匹配了，否则。。。

最简单的方法，使用正则表达式
以下正则表达式可以找出字符串中{}匹配的子串：
\{(?>[^\{\}]+|\{(?<DEPTH>)|\}(?<-DEPTH>))*(?(DEPTH)(?!))\}
如果剩余串中还有{ or }则说明不匹配。
（在.net下测试可行）
要匹配()[]只需将{}替换即可。

mark

既然没有时间看编译原理,那就只能用字符串查找来判断,看一个字符串中的"{"和"}"相等就可以了

mark

地方萨发生

的；;fkjdsajfkjdkl;fjals;djfklas范德萨发生法