精华内容
下载资源
问答
  • 数据结构括号匹配

    2018-07-04 14:22:50
    数据结构试验代码 数据结构试验代码数据结构试验代码数据结构试验代码
  • 数据结构 括号匹配

    2018-10-31 01:10:28
    /*括号匹配问题*/ #include<stdio.h> #include<stdlib.h> #include<string.h> #define stack_init_size 100 #define stackincrement 10 #define error ...

    三种括号形式( ),[ ],{ },输入一段字符串,判断其括号是否匹配。

    代码如下:

    /*括号匹配问题*/
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    #define stack_init_size 100
    #define stackincrement 10
    #define error 0
    #define true 1
    #define false 0
    #define overflow -2
    #define ok   1
    
    typedef int Status;
    typedef struct
    {
            char *base;
            char *top;
            int stacksize;
    }SqStack;
    /*初始化栈函数*/
    Status Initstack(SqStack&s)
    {
         s.base=(char*)malloc(stack_init_size*sizeof(char));
         if(!s.base)
             exit(overflow);
         s.top=s.base;
         s.stacksize=0;
         return ok;
    }
    
    /*入栈函数*/
    Status Push(SqStack &s,char c)
    {
        if(s.top-s.base>=s.stacksize)
        {
            s.base=(char*)realloc(s.base,(s.stacksize+stackincrement)*sizeof(char));
            if(!s.base)
               exit(overflow);
            s.top=s.base+s.stacksize;
            s.stacksize+=stackincrement;
        }
        *(s.top)=c;
        (s.top)++;
        return ok;
    }
    /*出栈函数*/
    Status Pop(SqStack &s)
    {
           if(s.top==s.base)
             return error;
            s.top--;
           return ok;
    }
    /*判断非空函数*/
    Status StackEmpty(SqStack &s) 
    {
           if(s.top==s.base)
             return true;
            else
              return false;
    }
    
    /*取栈顶元素*/
    Status Gettop(SqStack &s,char &c)
    {
           if(s.top==s.base)
               return error;
           c=*(s.top-1);
           return ok;
    }        
    
    /*检测匹配函数*/
    Status CheckBrackts(char *expr)
    {       
            SqStack s;int i;char c;
            Initstack(s);
           for(i=0;expr[i]!='\0';i++)
           {
                                    
              if(expr[i]=='('||expr[i]=='['||expr[i]=='{')
                Push(s,expr[i]);
              else
                  if(expr[i]==')'||expr[i]==']'||expr[i]=='}')
                  {
                     if(StackEmpty(s))
                          return  error; 
                     else{
                          Gettop(s,c);
                          switch(expr[i]){
                              case ')':if(c!='(')
                                         return error;  break;
                              case ']':if(c!='[')
                                         return error;  break;
                              case '}':if(c!='{')
                                         return error;  break;
                                         }//switch
                           Pop(s);
                          }//if-else
           
                   }//if
            }//for
            if(StackEmpty(s))
               {return ok;
               printf("abc\n");}
            else
             return error;
     }          
     
     /*主函数*/ 
     int main()
     {
           int result;
           char b[100];
           char *a=b;
           gets(b);
           //printf("%s\n",a);
           result=CheckBrackts(a);
           if(result==1)
            printf("yes");
           else
            printf("no");
            system("pause");
            return 0;
    }                         

     

    展开全文
  • C++语言写的数据结构括号匹配问题,数据结构课程作业。
  • 数据结构括号匹配问题 要求大、中、小括号两两匹配,基本思路可以通过栈来实现。这里我使用的是简单的静态顺序栈,大小固定,同时定义了栈顶指针top。程序包含了栈的几个最基本的操作,初始化、判空、压入、弹出,...

    数据结构括号匹配问题

    要求大、中、小括号两两匹配,基本思路可以通过栈来实现。这里我使用的是简单的静态顺序栈,大小固定,同时定义了栈顶指针top。程序包含了栈的几个最基本的操作,初始化、判空、压入、弹出,此外还有一个匹配函数,该函数接受一个数组和其长度做参数,判断是否括号匹配成功。然后是处理括号的问题,思路是扫描数组中的括号,遇到左括号就进行压栈操作,遇到右括号先判断栈中是否还有元素(即左括号),若没有则右括号“单身”,匹配失败,若栈中存在元素,就进行出栈操作,将栈顶的元素弹出与右括号进行配对,判断是否成功,在扫描完所有的括号后,判断栈中是否还有元素,若有,则左括号“单身”,匹配失败,若栈空,则最终匹配成功,结束程序。

    #include<stdio.h>
    #include<stdlib.h>
    #define OK 1
    #define TRUE 1
    #define FALSE 0
    #define ERROR 0
    #define OVERFLOW -1
    #define MAXSIZE 20
    typedef struct {
    	char data[MAXSIZE];
    	int top;
    }SqStack;
    typedef int Status;
    Status InitStack(SqStack* S) {
    	//构造一个空栈
    	S->top = -1;
    	return OK;
    }
    Status StackEmpty(SqStack S) {
    	if (S.top == -1) { printf("\n栈空!\n");return TRUE; }
    	else { return FALSE; }
    }
    Status Push(SqStack* S,char str) {
    	if (S->top==MAXSIZE-1) {
    		printf("\n栈满!\n");
    		exit(OVERFLOW);
    	}
    	S->data[++S->top] = str;
    	printf("\n压入元素%c\n", str);
    	return OK;
    }
    Status Pop(SqStack* S, char* str) {
    	if (S->top == -1) {
    		printf("\n栈空!\n");
    		return ERROR;
    	}
    	*str = S->data[S->top--];
    	printf("\n弹出元素%c\n", *str);
    	return OK;
    }
    Status Check(char str[], int length) {
    	SqStack S;
    	InitStack(&S);
    	printf("\n成功!\n");
    	for (int i = 0;i < length;i++) {
    		if (str[i] == '(' || str[i] == '[' || str[i] == '{') {
    			Push(&S, str[i]);//扫描到左括号,入栈
    		} else {
    			if (StackEmpty(S)) {
    				printf("\n匹配失败\n");
    				return FALSE;
    			}
    				
    			char topelem = '\0';
    			Pop(&S, &topelem);
    			if (str[i] == ')' && topelem != '(')
    			{
    				printf("\n匹配失败\n");
    				return FALSE;
    			}
    			if (str[i] == ']' && topelem != '[')
    			{
    				printf("\n匹配失败\n");
    				return FALSE;
    			}
    			if (str[i] == '}' && topelem != '{')
    			{
    				printf("\n匹配失败\n");
    				return FALSE;
    			}
    				
    		}
    			
    	}
    	if (StackEmpty(S)) { printf("\n匹配成功\n");return OK; }
    	else {
    		printf("\n匹配失败\n");
    		return FALSE;
    	}
    	return OK;
    }
    void main() {
    	printf("\n请向栈中写入括号(输入“#”结束输入):\n");
    	int temp = 0;
    	char string[MAXSIZE] = { '\0' };
    	for (int i = 0;;i++) {
    		scanf_s("%c", &string[i],sizeof(string));
    		if (string[i] == '#')break;
    		temp++;
    	}
    	Check(string, temp);
    }
    

    匹配成功截图
    在这里插入图片描述
    匹配失败截图
    在这里插入图片描述

    展开全文
  • 数据结构括号匹配程序c语言试验程序,实现括号自动匹配,支持文件操作20字符以内文件名。
  • 求大神帮看看程序哪里有问题(数据结构括号匹配),程序能运行,但是不管输入什么都显示匹配? ``` #include #include #include using namespace std; const int STACK_INIT_SIZE=100; const int ...
  • 括号匹配问题;制作过程;括号匹配问题的设计内容;算法思想描述;1算法 顺序扫描算数表达式表现为一个字符串当遇到三种类型的左括号时候让该括号进栈 当扫描到某一种类型的右括号时比较当前栈顶元素是否与之匹配若匹配...
  • 给定一个字符串,其中的字符只包含三种...括号匹配要求括号必须以正确的顺序配对,如 “{ [ ] ( ) }” 或 “[ ( { } [ ] ) ]” 等为正确的格式,而 “[ ( ] )” 或 “{ [ ( ) }” 或 “( { } ] )” 均为不正确的格式。
  • 利用循环链表实现的括号匹配数据结构实验报告,适合新手,有程序运行截图
  • 数据结构中利用栈实现括号匹配 本资源有两个文件 main.cpp Stack.h
  • 这是一份自己写的关于括号匹配数据结构用C++语言描述的实验,不对之处还请多多指教!
  • 是一个后进先出的数据结构。后进先出的意思就是后来进来的先出去。现实生活中有很多后进先出的例子,比如打印机的纸,餐馆的盘子等等。栈可以基于线性表或者链表创建。栈是一种特殊的线性表,其插入(入栈,压栈)与...
    f37d252c5ae5250cffa5328ce7468a4c.png什么是栈?栈与线性表类似,栈是他们的限制版本。栈只能够从一段插入一段删除。是一个后进先出的数据结构。后进先出的意思就是后来进来的先出去。现实生活中有很多后进先出的例子,比如打印机的纸,餐馆的盘子等等。栈可以基于线性表或者链表创建。栈是一种特殊的线性表,其插入(入栈,压栈)与删除(出栈,弹栈)都在同一段操作。作者自己写了一些东西来实现栈,但奇妙的是作者写的东西与C++的标准模板库冲突了。所以,我就干脆只用标准模板库的stack了。
    // 使用栈#include // 新建栈stack<int> A// 判断栈是否为空A.empty()// 压栈(添加一个数)A.push(i)// 弹栈(删除顶部的数)A.pop()// 返回栈的空间A.size()// 返回栈顶的元素A.top()
    以下是栈的测试
    // 栈的测试void Stack_A(){   stack<int> A;   // 判断栈是否为空   cout << A.empty() << endl;   for (int i = 1; i <= 10; i++)    {       cout << "压栈,数:" << i<< endl;       A.push(i);    }   // 输出栈的空间数量   cout << A.size() << endl;   for (int i = 1; i <= 10; i++)    {       cout << "弹栈,数:" << A.top()<< endl;       A.pop();    }}
    接下来讲一些奇奇怪怪的例题来使用栈f37d252c5ae5250cffa5328ce7468a4c.png第一、匹配括号
    “(()))(()(((()(()(()((()((())))()()”“((1+2)*3/5+(16*8)-1)”
    给你以上这么一组括号或一组字符串,判断他们的括号是否一一匹配。(())    这样就算匹配(()     这样就不算匹配()()  这样也算匹配这时候栈就变得非常实用。首先我们开始遍历数组,先寻找“(”,每找到一个就将其加入栈。如果找的数不是“(”,而是其他符号,则忽略。如果是“)”,则要弹栈,将前面的“(”弹出,说明匹配完成一个括号。最后,如果栈为空,则说明所有括号匹配完成。若栈还有,则就没有匹配完成。当然在过程中,若栈已经空了,又找到了“)”,那肯定也是没有匹配完成的。
    // 匹配括号void Match_Brackets(string strs){    stack<int> s;    int length = (int)strs.size();    // 扫描strs寻找左括号和有括号    for (int i = 0; i < length; i++)    {        // 左括号,压栈        if (strs.at(i) == '(')            s.push(i);        // 为右括号        else if (strs.at(i) == ')')        {            // 如果为右括号同时栈不为空            if (!s.empty())            {                s.pop();            }            else            {                cout << "括号不匹配!" << endl;                return;            }        }    }    // 遍历结束,栈不为空    if (!s.empty())    {        cout << "括号不匹配!" << endl;    }}
    f37d252c5ae5250cffa5328ce7468a4c.png这是一个小标题关于这个汉诺塔奇奇怪怪的神话就不提了……就是有三根柱子,一根柱子上有三个盘子要把第一根柱子的东西全部搬到第三根去,其中小盘子必须在大盘子上面,一次只能搬一个。这个貌似是有规律的,然后么,次数也是有规律的。次数:f(n)=2f(n-1)+1f(0)=0但不考虑次数,只考虑方法。如果我们要搬2个盘子那搬的顺序是:1->21->32->3那如果要搬n个呢?我们可以把n个分为1个与n-1个,那个1就是最大的那个。然后根据搬2个盘子的顺序来就行。那n-1怎么搬?那就把n-1分为n-2与1。以此类推,推到1为止,再把每一步都展示出来,就完成了。听起来真的很简单,但…………想起来真的很难不能多想不能多想一切关于递归的问题不能多想,越想越复杂。如果想弄清递归的每一步,那是不可能的,要看递归到底是什么,到底在解决什么。而不是去探究每一步都在做什么。(说实话我就是没有好好学递归…………经典问题都没研究过…………)我先上递归实现代码。
    // 递归解决汉诺塔问题void Towers_Of_Hanoi(int n, int x, int y, int z){    if (n > 0)    {        // 将n-1从塔1搬到塔2        Towers_Of_Hanoi(n - 1, x, z, y);        // 将最底下的盘子从塔1搬到塔3        cout << "移动顶端的盘子从" << x << "到" << y << endl;        // 将n-1从塔2搬到塔3        Towers_Of_Hanoi(n - 1, z, y, x);    }}

    如果想要数据可视化,就可以用到栈来储存每一步的数据。
    上代码
    // 全局变量stack<int> tower[4];void moveAndShow(int, int, int, int);// 使用栈解决汉诺塔问题void towersOfHanoi(int n){    for (int d = n; d > 0; d--)     // 塔的空间        tower[1].push(d);           // 加入盘子    // 开始移动,将盘子由1,依赖3移动到2    moveAndShow(n, 1, 2, 3);}// 此处注意是将x移动到y塔上,而不是z塔上void moveAndShow(int n, int x, int y, int z){    // 将n个盘子从x塔依赖z塔移动到y塔,并且显示状态    if (n > 0)    {        moveAndShow(n - 1, x, z, y);        int d = tower[x].top();   // 移动顶端        tower[x].pop();           // 弹栈        tower[y].push(d);         // 压栈        // showState();              // 展示        // 展示移动过程        cout << "移动盘子" << d << "从塔" << x << "到塔" << y << endl;        moveAndShow(n - 1, z, y, x);    }}

    018fa0d46da592750fb199809e389301.png

    展开全文
  • 给定一串字符,不超过100个字符,可能包括括号、数字、字母、标点符号、空格,编程检查这一串字符中的( ) ,[ ],{ }是否匹配。 输入格式: 输入在一行中给出一行字符串,不超过100个字符,可能包括括号、数字、字母、...

    给定一串字符,不超过100个字符,可能包括括号、数字、字母、标点符号、空格,编程检查这一串字符中的( ) ,[ ],{ }是否匹配。

    输入格式:
    输入在一行中给出一行字符串,不超过100个字符,可能包括括号、数字、字母、标点符号、空格。

    输出格式:
    如果括号配对,输出yes,否则输出no。

    我的答案

    #include <stdio.h>
    #include <stdbool.h>
    
    typedef char ElementType;
    typedef struct Node* PtrToNode;
    
    struct Node 
    {
        ElementType Data;
        PtrToNode   Next;
    };
    typedef PtrToNode Stack;
    
    Stack Create();
    bool IsEmpty(Stack L);
    bool Push(Stack L, ElementType x);
    ElementType Pop(Stack L);
    bool March(char s[]);
    
    int main()
    {
        char s[101];
        gets(s);
        if (March(s)) 
            printf("yes\n");
        else 
            printf("no\n");
    }
    
    Stack Create()
    {
        Stack L = (Stack)malloc(sizeof(struct Node));
        L->Next = NULL;
        return L;
    }
    
    bool IsEmpty(Stack L)
    {
        return (L->Next == NULL);
    }
    
    bool Push(Stack L, ElementType x)
    {
        bool flag = false;
        Stack p = (Stack)malloc(sizeof(struct Node));
        p->Data = x;
        p->Next = L->Next;
        L->Next = p;
        flag = true;
        return flag;
    }
    
    ElementType Pop(Stack L)
    {
        if (IsEmpty(L))
            return 0;
        else
        {
            ElementType flag = L->Next->Data;
            Stack p;
            p = L->Next;
            L->Next = p->Next;
            free(p);
            return flag;
        }
    }
    
    bool March(char chr[]) 
    {
        int i = 0;
        char x;
        bool flag = true;
        Stack L = Create();
      
        while (chr[i]) 
        {
            if (chr[i] == '(' || chr[i] == '[' || chr[i] == '{') 
                Push(L, chr[i]);
            if (chr[i] == ')') 
            {
                x = Pop(L);
                if (x != '(') 
                {
                    flag = false;
                    break;
                }
            }
            if (chr[i] == ']') 
            {
                x = Pop(L);
                if (x != '[') 
                {
                    flag = false;
                    break;
                }
            }
            if (chr[i] == '}') 
            {
                x = Pop(L);
                if (x != '{') 
                {
                    flag = false;
                    break;
                }
            }
            i++;
        }
      
        if (!IsEmpty(L))
            flag = false;
        return flag;
    }
    
    
    展开全文
  • C++数据结构括号匹配

    2011-08-10 08:36:31
    1. 设表达式以字符形式已存入数组E[n]中,‘#’为表达式的结束符,试写出判断表达式中括号(‘(’和‘)’‘['和’]';'{'和'}')是否配对的算法
  • 本文转载于 SegmentFault 社区作者:打了个冷颤有效的括号编写程序时, 一个类, 函数, 表达式, 都需要括号匹配,如果括号没有正确匹配,编译器就会报错, 这其实一种是数据结构--栈的应用。栈(Stack)是一种线性结构只能...
  • //如果c和当前右括号匹配,返回false; } } } if (s.empty()) return true; //表达式遍历结束后,判断此时栈内是否还有元素,没有则返回true; else return false; //如果有说明有多余的左括号...
  • 数据结构 括号匹配的检验

    千次阅读 2019-08-05 16:10:42
    #include #include #define MAXSIZE 100 struct Stack { char* base; char* top; int size;... S->base = (char*)malloc(sizeof... printf("匹配成功"); else printf("匹配失败"); while (1); } –n,n-1
  • 什么是数据结构栈是一种数据结构。那什么是数据结构呢?我这里不给出严格的定义,因为对于完全没有基础的新人而言,严格的定义说了等于没说。我只从一个简单的角度举例说明一下。在初学阶段,你可以认为数据结构就是...
  • 这次又重新学习python的数据结构及算法(中国MOOC上的公开课),就好好做个笔记吧。栈是一种只能在一端进行插入和删除的线性数据结构。一般来说,栈主要有两个操作:一个是进栈(PUSH),又叫作入栈、压栈;另一个是出栈...
  • 括号匹配 数据结构 match 没有错误 可以运行。 好的顶一下
  • 已经不知道是哪里的题了,基础的入栈出栈括号匹配 #include &lt;iostream&gt; #include &lt;stack&gt; #include &lt;cstring&gt; using namespace std; int main(void) { char s[10005]...
  • 你是否快要被C语言进阶版的数据结构秃光了头呢?在紧张的考试之前,精英计划团快马加鞭地为大家整理出了考试的重点,快来吃安利吧!!数据结构第一次测验大复习※数据的组织方式四种基本的数据结构为集合、树、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,161
精华内容 864
关键字:

数据结构括号匹配

数据结构 订阅