括号匹配c语言

① c语言的括号匹配怎么写啊

了解一下数据结构中的栈(其实就是后入先出)，你就知道该怎么实现了。
知道怎么实现栈后就很简单了：遇到左括号则入栈，遇到右括号则检查栈内是否有元素，没有元素则结果不匹配，有元素则弹出栈顶元素来查看是否符号相匹配。而检查完毕后如果栈内仍有元素，则不匹配，无元素则匹配

② c语言的括号匹配问题

#include <stdio.h>

#include <stdlib.h>

int main()

{

int i,count;

char ch[10001],ch1[10001];

while(gets(ch)!=NULL)

{

count=-1;

for(i=0;ch[i]!='';i++)

{

if(ch[i]=='('||ch[i]=='['||ch[i]=='<'||ch[i]=='{')

{

ch1[++count]=ch[i];

}

else

{

if(ch[i]-ch1[count]<3)

{

count--;

}

else

{

break;

}

}

}

if(count==-1)

printf("YES ");

else

printf("NO ");

}

return 0;

}

③ 求用C语言做简单的括号匹配程序

头文件：（另存为SeqStack.h）
typedef struct
{
DataType stack[MaxStackSize];
int top;
} SeqStack;

void StackInitiate(SeqStack *S) /*初始化顺序堆栈S*/
{
S->top = 0; /*定义初始栈顶下标值*/
}

int StackNotEmpty(SeqStack S)
/*判顺序堆栈S非空否，非空则返回1，否则返回0*/
{
if(S.top <= 0) return 0;
else return 1;
}

int StackPush(SeqStack *S, DataType x)
/*把数据元素值x压入顺序堆栈S，入栈成功则返回1，否则返回0 */
{
if(S->top >= MaxStackSize)
{
printf("堆栈已满无法插入! \n");
return 0;
}
else
{
S->stack[S->top] = x;
S->top ++;
return 1;
}
}

int StackPop(SeqStack *S, DataType *d)
/*弹出顺序堆栈S的栈顶数据元素值到参数d ，出栈成功则返回1，否则返回0*/
{
if(S->top <= 0)
{
printf("堆栈已空无数据元素出栈! \n");
return 0;
}
else
{
S->top --;
*d = S->stack[S->top];
return 1;
}
}

int StackTop(SeqStack S, DataType *d)
/*取顺序堆栈S的当前栈顶数据元素值到参数d ，成功则返回1，否则返回0*/
{
if(S.top <= 0)
{
printf("堆栈已空! \n");
return 0;
}
else
{
*d = S.stack[S.top - 1];
return 1;
}
}

括号问题
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#define MaxStackSize 100
typedef char DataType;
#include "SeqStack.h"

void ExpIsCorrect(char exp[], int n)
//判断有n个字符的字符串exp左右括号是否配对正确
{
SeqStack myStack; //定义链式堆栈
int i;
char c;

StackInitiate(&myStack);
for(i = 0; i < n; i++)
{
if((exp[i] == '(') || (exp[i] == '[') || (exp[i] == '{'))
StackPush(&myStack, exp[i]); //入栈

else if(exp[i] == ')' && StackNotEmpty(myStack)
&& StackTop(myStack, &c) && c == '(')
StackPop(&myStack, &c); //出栈
else if(exp[i] == ')' && StackNotEmpty(myStack)
&& StackTop(myStack, &c) && c != '(')
{
printf("左右括号配对次序不正确！\n");
return;
}

else if(exp[i] == ']' && StackNotEmpty(myStack)
&& StackTop(myStack, &c) && c == '[')
StackPop(&myStack, &c); //出栈
else if(exp[i] == ']' && StackNotEmpty(myStack)
&& StackTop(myStack, &c) && c != '[')
{
printf("左右括号配对次序不正确！\n");
return;
}

else if(exp[i] == '}' && StackNotEmpty(myStack)
&& StackTop(myStack, &c) && c == '{')
StackPop(&myStack, &c); //出栈
else if(exp[i] == '}' && StackNotEmpty(myStack)
&& StackTop(myStack, &c) && c != '{')
{
printf("左右括号配对次序不正确！\n");
return;
}

else if(((exp[i] == ')') || (exp[i] == ']') || (exp[i] == '}'))
&& !StackNotEmpty(myStack))
{
printf("右括号多于左括号！\n");
return;
}
}

if(StackNotEmpty(myStack))
printf("左括号多于右括号！\n");
else
printf("左右括号匹配正确！\n");
}

void main(void)
{
char a[] = "(())abc{[)(]}"; //测试例子1。左右括号配对次序不正确
char b[] = "(()))abc{[]}"; //测试例子2。右括号多于左括号
char c[] = "(()()abc{[]}"; //测试例子3。左括号多于右括号
char d[] = "(())abc{[]}"; //测试例子4。左右括号匹配正确
int n1 = strlen(a);
int n2 = strlen(b);
int n3 = strlen(c);
int n4 = strlen(d);

ExpIsCorrect(a, n1);
ExpIsCorrect(b, n2);
ExpIsCorrect(c, n3);
ExpIsCorrect(d, n4);
}

二者放于同一目录下即可

④ 判断圆括号是否配对用C语言如何实现

1、设计原理：
主要是利用了栈的结构，在表达式的输入过程中实现对括号是否匹配的判断。根据其括号的原则：小括号之中不能含有大括号或中括号，中括号中不能含有大括号。再由紧密性，左边括号和右边括号是紧密相连的。否则判断为错。 其操作为：每输入一个字符打一下回车，若输入括号顺序错误则跳出，并显示错误！
2、例程：

#include<stdio.h>
#defineMAX100
#defineTRUE1
#defineFALSE0
#defineEa

typedefstructtransition/*建立一个栈*/
{
charsq[MAX];
inttop;
}sqstack;

sqstackbt;
intemptysqstack(sqstackbt)/*判栈空*/
{
if(bt.top==-1)
returnTRUE;
else
returnFALSE;
}
voidpushsqstack(sqstackbt,charsh)/*入栈*/
{
if(bt.top==MAX-1)
{
printf("overflow");
exit(0);
}
bt.top++;
bt.sq[bt.top]=sh;
}
voidpopsqstack(sqstackbt)/*出栈*/
{
intsh;
if(bt.top==-1)
{
printf("empty");
exit(0);
}
sh=bt.sq[bt.top];
bt.top--;
returnsh;
}
Search(sqstackbt)/*查找括号是否匹配*/
{
charc=0;
printf("Ifyouwanttobreak,pleaseinput'a'
");
while(c!=E&&bt.top<=MAX&&c!='('&&c!='['&&c!='{')
{
c=getchar();
pushsqstack(bt,c);
}
SearchA(bt,c);
SearchB(bt,c);
SearchC(bt,c);
}
SearchA(sqstackbt,charc)/*查找小括号是否匹配*/
{
if(c=='(')
{
while(c!=')'&&c!='['&&c!=']'&&c!='{'&&c!='}')
{
c=getchar();
pushsqstack(bt,c);
}
if(c=='(')
printf("right
");
elseif(c=='['||c==']'||c=='{'||c=='}')
printf("wrong
");
}
}
SearchB(sqstackbt,charc)/*查找中括号是否匹配*/
{
if(c=='[')
while(c!=']'&&c!='('&&c!=')'&&c!='{'&&c!='}')
{
c=getchar();
pushsqstack(bt,c);
}
if(c==')'||c=='{'||c=='}')
printf("wrong
");
elseif(c=='(')
SearchA(bt,c);
elseif(c==']')
printf("right
");
else
printf("wrong
");
}
SearchC(sqstackbt,charc)/*查找大括号是否匹配*/
{
if(c=='{')
while(c!='}'&&c!='['&&c!=']'&&c!='('&&c!=')')
{
c=getchar();
pushsqstack(bt,c);
}
if(c==']'||c==')')
printf("wrong
");
elseif(c=='[')
SearchB(bt,c);
elseif(c=='(')
SearchA(bt,c);
elseif(c=='}')
printf("right
");
else
printf("wrong
");
}
main()
{
inti;
bt.top=-1;
i=emptysqstack(bt);
if(i)
{
Search(bt);
}
else
exit(0);

}

⑤ 括号匹配检验（c语言）

函数返回值类型不能是Status，Status只是泛指类型，至于具体用什么类型，你应该根据实际情况而定。
比如你的第一个函数Status InitStack(SqStack &S) ，
可以改为int InitStack(SqStack &S) ，其它的你自己根据情况定了。

⑥ 求c语言高手，括号配对问题

Status matching(char exp[])
{
int state = 1; i=0,ii=0;
while (i<=Length(exp) && state)
{
switch of exp[i]
{
case ‘(’:
case ‘[’ :
{Push(S,exp[i]); i++; break;}
case ‘)’ :
if(NOT StackEmpty(S)&&GetTop(S)=“(“)
{Pop(S,e); ii++;} else {state = 0;} return No;
case ‘]’ :
if(NOT StackEmpty(S)&&GetTop(S)=“[“)
{Pop(S,e); ii++;} else {state = 0;} return No;
}//switch
if (StackEmpty(S)&&state) return YES;
}

以上我给出你的，是一个伪代码。

你的问题要用到数据结构里的栈。

遇到（或者[ ，就把它压入栈内。

遇到）或者] ，首先检测栈是不是为空，如果不为空，在返回栈顶元素，如果匹配，即为“（”或者“[”，就删除栈顶元素，然后重复。

当栈变空了，说明你的括号都配对了，也就YES了。

如果途中出现不配对的情况，就直接返回NO。

求给最佳答案！

⑦ 求C语言括号配对问题答案

头文件：（另存为SeqStack.h）
typedef
struct
{
DataType
stack[MaxStackSize];
int
top;
}
SeqStack;
void
StackInitiate(SeqStack
*S)
/*初始化顺序堆栈S*/
{
S->top
=
0;
/*定义初始栈顶下标值*/
}
int
StackNotEmpty(SeqStack
S)
/*判顺序堆栈S非空否，非空则返回1，否则返回0*/
{
if(S.top
<=
0)
return
0;
else
return
1;
}
int
StackPush(SeqStack
*S,
DataType
x)
/*把数据元素值x压入顺序堆栈S，入栈成功则返回1，否则返回0
*/
{
if(S->top
>=
MaxStackSize)
{

printf("堆栈已满无法插入!
\n");

return
0;
}
else
{

S->stack[S->top]
=
x;

S->top
++;

return
1;
}
}
int
StackPop(SeqStack
*S,
DataType
*d)
/*弹出顺序堆栈S的栈顶数据元素值到参数d
，出栈成功则返回1，否则返回0*/
{
if(S->top
<=
0)
{

printf("堆栈已空无数据元素出栈!
\n");

return
0;
}
else
{

S->top
--;

*d
=
S->stack[S->top];

return
1;
}
}
int
StackTop(SeqStack
S,
DataType
*d)
/*取顺序堆栈S的当前栈顶数据元素值到参数d
，成功则返回1，否则返回0*/
{
if(S.top
<=
0)
{

printf("堆栈已空!
\n");

return
0;
}
else
{

*d
=
S.stack[S.top
-
1];

return
1;
}
}
括号问题
#include
<string.h>
#include
<stdio.h>
#include
<stdlib.h>
#define
MaxStackSize
100
typedef
char
DataType;
#include
"SeqStack.h"
void
ExpIsCorrect(char
exp[],
int
n)
//判断有n个字符的字符串exp左右括号是否配对正确
{
SeqStack
myStack;
//定义链式堆栈
int
i;
char
c;
StackInitiate(&myStack);
for(i
=
0;
i
<
n;
i++)
{

if((exp[i]
==
'(')
||
(exp[i]
==
'[')
||
(exp[i]
==
'{'))

StackPush(&myStack,
exp[i]);
//入栈

else
if(exp[i]
==
')'
&&
StackNotEmpty(myStack)

&&
StackTop(myStack,
&c)
&&
c
==
'(')

StackPop(&myStack,
&c);
//出栈

else
if(exp[i]
==
')'
&&
StackNotEmpty(myStack)

&&
StackTop(myStack,
&c)
&&
c
!=
'(')

{

printf("左右括号配对次序不正确！\n");

return;

}

else
if(exp[i]
==
']'
&&
StackNotEmpty(myStack)

&&
StackTop(myStack,
&c)
&&
c
==
'[')

StackPop(&myStack,
&c);
//出栈

else
if(exp[i]
==
']'
&&
StackNotEmpty(myStack)

&&
StackTop(myStack,
&c)
&&
c
!=
'[')

{

printf("左右括号配对次序不正确！\n");

return;

}

else
if(exp[i]
==
'}'
&&
StackNotEmpty(myStack)

&&
StackTop(myStack,
&c)
&&
c
==
'{')

StackPop(&myStack,
&c);
//出栈

else
if(exp[i]
==
'}'
&&
StackNotEmpty(myStack)

&&
StackTop(myStack,
&c)
&&
c
!=
'{')

{

printf("左右括号配对次序不正确！\n");

return;

}

else
if(((exp[i]
==
')')
||
(exp[i]
==
']')
||
(exp[i]
==
'}'))

&&
!StackNotEmpty(myStack))

{

printf("右括号多于左括号！\n");

return;

}
}
if(StackNotEmpty(myStack))

printf("左括号多于右括号！\n");
else

printf("左右括号匹配正确！\n");
}
void
main(void)
{
char
a[]
=
"(())abc{[)(]}";
//测试例子1。左右括号配对次序不正确
char
b[]
=
"(()))abc{[]}";
//测试例子2。右括号多于左括号
char
c[]
=
"(()()abc{[]}";
//测试例子3。左括号多于右括号
char
d[]
=
"(())abc{[]}";
//测试例子4。左右括号匹配正确
int
n1
=
strlen(a);
int
n2
=
strlen(b);
int
n3
=
strlen(c);
int
n4
=
strlen(d);
ExpIsCorrect(a,
n1);
ExpIsCorrect(b,
n2);
ExpIsCorrect(c,
n3);
ExpIsCorrect(d,
n4);
}
二者放于同一目录下即可

⑧ 括号的匹配问题(C语言)

说实话，问题真的很多，给你简单修改了一下，这应该可以跑对了，你自己对照一下看看有什么问题吧。
#include <stdio.h>
#include <string.h>
#include <malloc.h>
typedef struct stack
{
char data;
struct stack *link;
}*JD;
int creatstack(char a[20])
{
JD p,s,t;
char x;
int n=0, len = 0;
p=(JD)malloc(sizeof(JD));
p->link=NULL;
while(a[len] != '\0')
{
x=a[len];
switch(x)
{
case '(':
case '[':
case '{'://若输入的是左括号，则压入栈中
s=(JD)malloc(sizeof(JD));
s->data=x;
s->link=p->link;
p->link=s;
n++;
break;
case ')':
case ']':
case '}'://若输入的是右括号
if(n==0) return 0;//先判断是否为第一个输入，若是则返回错误
t=p->link;
if(x==t->data+1)//用ACSII码值来检测()是否匹配
{
p->link=t->link;
free(t);
n--;
}
else if(x==t->data+2)//用ACSII码值来检测[]和{}是否匹配
{
p->link=t->link;
free(t);
n--;
}
else return 0;//若不匹配则返回错误
break;
default :
return -1;
}
++len;
}
if(!n)
return 1;
return -1;
}
int main()
{
int i;
char a[20];
printf("请输入括号组\n");
gets(a);
if(strlen(a)%2==1)
printf("括号不匹配\n");
i=creatstack(a);
if(i==0)
printf("括号不匹配\n");
else if(i==1)
printf("括号匹配\n");
else
printf("输入错误\n");
}

其实可以简化一下（用静态的存储足够）：
#include<stdio.h>
#include<string.h>
int _str(char *a)
{
int len=strlen(a), top=1;
char stack[500];
memset(stack, 0, sizeof(stack));
if(a[0]=='\n'||a[0]=='\0')
return 1;
stack[top]=a[0];
for(int i=1; i<len; i++)
if((stack[top]=='('&&a[i]==')')
||(stack[top]=='['&&a[i]==']')
||(stack[top]=='{'&&a[i]=='}')
)
top--;
else
stack[++top]=a[i];
if(!top)
return 1;
return 0;
}
int main()
{
char a[500];
int flag;
gets(a);
flag = _str(a);
if(flag)
puts("括号匹配。");
else
puts("括号不匹配。");
return 0;
}

⑨ C语言：表达式括号匹配检验（压栈，出栈)

算法提示：
1）凡出现左括号，则进栈；
2）凡出现右括号，首先检查栈是否空
若栈空，则表明该“右括号”多余，
否则和栈顶元素比较，
若相匹配，则“左括号出栈”
，
否则表明不匹配。
3）表达式检验结束时，
若栈空，则表明表达式中匹配正确，
否则表明“左括号”有余。

⑩ C语言编程：括号完美匹配；下面这个程序哪里错了

#include<stdio.h>

intmain()
{
inti,j,n,top=-1;
chars[1010],w[1010];//w为括号的栈，top为栈顶
scanf("%d",&n);
getchar();
for(i=0;i<n;i++)
{
gets(s);
for(j=0;s[j]!='';j++)//遍历每一个字符串
{
if(s[j]=='('||s[j]=='[')//如果是左括号，将其入栈
w[++top]=s[j];
elseif(s[j]==')')//如果是右小括号，判断是否匹配
{
if(w[top]=='(')
top--;
else
{
printf("no
");
break;
}
}
elseif(s[j]==']')//如果是右中括号，判断是否匹配
{
if(w[top]==']')
top--;
else
{
printf("no
");
break;
}
}
}
if(s[j]=='')//如果循环没有在中间跳出，检查栈顶位置，最终检查是否匹配
{
if(top==-1)
printf("yes
");
else
printf("no
");
}
}
return0;
}

你写的逻辑混乱，思路也不清晰。看看我的吧。