栈

最新推荐文章于 2021-10-17 21:46:58 发布
最新推荐文章于 2021-10-17 21:46:58 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 知识点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangzhenjunaixuxin/article/details/82819928
版权

设一个堆栈的入栈顺序是1、2、3、4、5。若第一个出栈的元素是4，则最后一个出栈的元素必定是：4 (2分)

  1. 1
  2. 3
  3. 5
  4. 1或者5

允许出栈和进栈交替进行

7-2 符号配对 （20 分）

请编写程序检查C语言源程序中下列符号是否配对：/*与*/、(与)、[与]、{与}。

输入格式:

输入为一个C语言源程序。当读到某一行中只有一个句点.和一个回车的时候，标志着输入结束。程序中需要检查配对的符号不超过100个。

输出格式:

首先，如果所有符号配对正确，则在第一行中输出YES，否则输出NO。然后在第二行中指出第一个不配对的符号：如果缺少左符号，则输出?-右符号；如果缺少右符号，则输出左符号-?。

输入样例1：

void test()
{
    int i, A[10];
    for (i=0; i<10; i++) /*/
        A[i] = i;
}
.

输出样例1：

NO
/*-?

输入样例2：

void test()
{
    int i, A[10];
    for (i=0; i<10; i++) /**/
        A[i] = i;
}]
.

输出样例2：

NO
?-]

输入样例3：

void test()
{
    int i
    double A[10];
    for (i=0; i<10; i++) /**/
        A[i] = 0.1*i;
}
.

输出样例3：

YES

作者: DS课程组

单位: 浙江大学

时间限制: 400 ms

内存限制: 64 MB

#define debug(a,n) for(int i=0;i<n;++i)cout<<a[i]<<' ';cout<<endl;
#define FRER() freopen("i.txt","r",stdin)
//库函数头文件包含
#include<bits/stdc++.h>
//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2
using namespace std;
typedef int  Status;
typedef  char SElemType; //假设线性表中的元素均为整型
typedef struct
{
    SElemType *base;
    SElemType *top;
} SqStack;
Status InitStack(SqStack &S)
{
    int M=100;
    S.base=(SElemType*)malloc(M*sizeof(SElemType));
    if(S.base==NULL)
        exit(ERROR);
    S.top=S.base;
    return OK;
}
Status Push(SqStack &S,SElemType e)
{
    *(S.top)=e;
    S.top++;
    return OK;
}
Status Pop(SqStack &S)
{
    S.top--;
}
SElemType Top(SqStack &S)
{
    return *(S.top-1);
}
Status Empty(SqStack &S)
{
    if(S.base==S.top)
        return OK;
    else
        return ERROR;
}
char c;
bool Compair(SqStack &S)
{
    char ch[200];
    int flag=1;
    while(cin.getline(ch,sizeof(ch)))//sizeof(ch)==200,gets在c++11中已不能使用
    {
        if(ch[0]=='.'&&ch[1]=='\0')
            break;
        for(int i=0; ch[i]!='\0'; i++)
        {
            if(ch[i]=='('||ch[i]=='{'||ch[i]=='[')
            {
               Push(S,ch[i]);
            }
            else  if(ch[i]=='/'&&ch[i+1]=='*')
            {
                Push(S,ch[i]);
                Push(S,ch[i+1]);
                i++;
            }
            else if(ch[i]=='*'&&ch[i+1]=='/')
            {
                if(!Empty(S)&&Top(S)=='*')
                {
                    Pop(S);
                    if(!Empty(S)&&Top(S)=='/')
                    {
                        Pop(S);
                        i++;
                    }
                    else
                    {
                        c=ch[i];
                        flag=0;
                        break;
                    }
                }
                else
                {
                    c=ch[i];
                    flag=0;
                    break;
                }
            }
            else if(ch[i]==')')
            {
                if(!Empty(S)&&Top(S)=='(')
                {
                    Pop(S);
                }
                else
                {
                    c=ch[i];
                    flag=0;
                    break;
                }
            }
            else if(ch[i]=='}')
            {
                if(!Empty(S)&&Top(S)=='{')
                {
                    Pop(S);
                }
                else
                {
                    c=ch[i];
                    flag=0;
                    break;
                }
            }
            else if(ch[i]==']')
            {
                if(!Empty(S)&&Top(S)=='[')
                {
                    Pop(S);
                }
                else
                {
                    c=ch[i];
                    flag=0;
                    break;
                }
            }
        }
    }
    if(Empty(S)&&flag)
        return true;
    else
        return false;
}
int main()
{
SqStack S;
    InitStack(S);
    if(Compair(S))
        printf("YES\n");
  else
  {  printf("NO\n");
      if(!Empty(S))
      {
          if(Top(S)=='*')
            printf("/*-?");
          else if(Top(S)=='{')
            printf("{-?");
        else if(Top(S)=='(')
                    printf("(-?");
        else if(Top(S)=='[')
            printf("[-?");
      }
      else
      { if(c=='*')
      printf("?-*/");
      else
        printf("?-%c",c);
      }
  }
    return 0;
}
///*/或*/是成对出现的，而且总会出现一对不行，其他的不可以

中缀式转后缀式规则

****遇到数字直接输出，遇到左括号直接放进栈中，遇到右括号将栈顶元素依次输出直到遇到左括号（左括号也删除，右括号不再放进去），其他操作符直接和栈顶元素比较，1，优先级比栈顶元素低，栈顶元素依次出栈直到出现比该操作符优先级更小的（相同操作符也输出），该操作符最后还要放入栈中。2否则直接将该操作符放入栈中。最后将栈清空（乘除优先加减）

****

 

7-1 表达式转换 （25 分）

算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。日常使用的算术表达式是采用中缀表示法，即二元运算符位于两个运算数中间。请设计程序将中缀表达式转换为后缀表达式。

输入格式:

输入在一行中给出不含空格的中缀表达式，可包含+、-、*、\以及左右括号()，表达式不超过20个字符。

输出格式:

在一行中输出转换后的后缀表达式，要求不同对象（运算数、运算符号）之间以空格分隔，但结尾不得有多余空格。

输入样例:

2+3*(7-4)+8/4

输出样例:

2 3 7 4 - * + 8 4 / +

 

#define debug(a,n) for(int i=0;i<n;++i)cout<<a[i]<<' ';cout<<endl;
#define FRER() freopen("i.txt","r",stdin)
//库函数头文件包含
#include <stdio.h>
#include <stdlib.h>

//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2
using namespace std;
typedef int  Status;
typedef  char SElemType; //假设线性表中的元素均为整型
typedef struct
{
    SElemType *base;
    SElemType *top;
} SqStack;
Status InitStack(SqStack &S)
{
    int M=60;
    S.base=(SElemType*)malloc(M*sizeof(SElemType));
    if(S.base==NULL)
        exit(ERROR);
    S.top=S.base;
    return OK;
}
Status Push(SqStack &S,SElemType e)
{
    *(S.top)=e;
    S.top++;
    return OK;
}
Status Pop(SqStack &S)
{
    S.top--;
}
SElemType Top(SqStack &S)
{
    return *(S.top-1);
}
char c='&';//用这种符号来分割后缀式的所有元素，好输出
Status Empty(SqStack &S)
{
    if(S.base==S.top)
        return OK;
    else
        return ERROR;
}
bool Number(SElemType e)
{
    if(e>='0'&&e<='9')
        return OK;
    else
        return ERROR;
}
bool Bigger(SElemType e,SElemType f)
{
    //比较栈顶元素和其他的元素的大小的大小
    if(e==f)
        return OK;
    if(e=='(')
        return ERROR;
    //按在字符串中的顺序看符号优先级
    char ch[4]= {'+','-','*','/'};
    int i,j;
    for(i=0; i<=4; i++)
        if(ch[i]==e)
            break;
    for(j=0; j<=4; j++)
        if(ch[j]==f)
            break;
    if(i<j)
        return ERROR;
    return OK;
}
int main()
{
    SqStack S;
    InitStack(S);
    SElemType ch[50];
    SElemType che[100];
    int flag=0;
    int first=0;
    scanf("%s",ch);
    for(int i=0; ch[i]!='\0'; i++)
    {//考虑（负数/正数）的情况
        if(ch[i]=='-'||ch[i]=='+')
        {
            if(i>0)
            {
                if(ch[i-1]=='(')
                {
                    if(ch[i]=='+')
                        continue;
                    else
                    {
                        che[flag++]=c;
                        che[flag++]='-';
                        first=1;
                        continue;
                    }
                }
            }
        }
        //考虑出现小数的情况
        if(ch[i]=='.')
        {
            che[flag++]='.';
            continue;
        }
        //考虑开头出现负数的情况，不会出现带+的正数
        if(ch[i]=='-'&&i==0)
        {
            che[flag++]=c;
            che[flag++]='-';
            first=1;
            continue;
        }
        if(Number(ch[i]))
        {
            if(first==0)
                che[flag++]=c;
            che[flag++]=ch[i];
            first=1;
        }
        else if(Empty(S))
        {
            Push(S,ch[i]);
            first=0;
            continue;
        }
        else if(ch[i]==')')
        {
            while(Top(S)!='(')
            {
                che[flag++]=c;
                che[flag++]=Top(S);
                Pop(S);
            }
            Pop(S);
            first=0;
            continue;
        }
        else if(Bigger(Top(S),ch[i])&&ch[i]!='(')
        {
            while(!Empty(S)&&Bigger(Top(S),ch[i]))
            {
                che[flag++]=c;
                che[flag++]=Top(S);
                Pop(S);
            }
            Push(S,ch[i]);
            first=0;
            continue;
        }
        else
        {
            first=0;
            Push(S,ch[i]);
        }
    }
    while(!Empty(S))
    {
        che[flag++]=c;
        che[flag++]=Top(S);
        Pop(S);
    };
    for(int i=1; i<flag; i++)
    {
        if(che[i]=='&')
            printf(" ");
        else
            printf("%c",che[i]);
    }
    return 0;
}
 

该题最重要的是考虑以下几种情况

 
序号输入输出
1 
2+3*(7-4)+8/4

2 3 7 4 - * + 8 4 / +
2 
((2+3)*4-(8+2))/5

2 3 + 4 * 8 2 + - 5 /
3 
1314+25.5*12

1314 25.5 12 * +
4 
-2*(+3)

-2 3 *
5 
123

123

..................................................................................................................................................................................

//递归输入并创建链表
Status ListCreate_L_Rec(LinkList &L,int n)
{
//递归边界：创建空表时只需将L赋空即可；
//递归关系：创建非空表时，将链表看做两部分：首元素组成的子表La， 第二个元素及其后元素构成的子表Lb。
//子表La容易创建(只需开辟一个节点)
//子表Lb由于规模小可以递归创建完成（类似数学归纳法的假设，只要小的都可以建设能完成）
//最后将两个子表拼接即可。
  LNode *La, *Lb;
  if(n==0) L=NULL;
  else{
    La=(LNode *)malloc(sizeof(LNode));  //开辟子表La
    if(!La) exit(OVERFLOW);
    scanf("%d",&La->data);
    ListCreate_L_Rec(Lb,n-1 ); //递归创建子表Lb
    La->next = Lb;  //两个子表拼结
    L=La;  //第一个子表的地址赋给L。请思考为什这样处理不会使得主函数中的L取错值？
  }
  return OK;
}

//递归输出链表

void ListPrint_L_Rec(LinkList L)
{
    if(L==NULL)
    {
        return;
    }
    else
    {
        printf(" %d",L->data);
    }
    ListPrint_L_Rec(L->next);
}
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

xx_zzj
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PTA-符号配对（C++实现）
qq_43528395的博客
03-24 1863
符号配对 请编写程序检查C语言源程序中下列符号是否配对：/与/、(与)、[与]、{与}。 输入格式: 输入为一个C语言源程序。当读到某一行中只有一个句点.和一个回车的时候，标志着输入结束。程序中需要检查配对的符号不超过100个。 输出格式: 首先，如果所有符号配对正确，则在第一行中输出YES***，否则输出NO***。然后在第二行中指出第一个不配对的符号：如果缺少左符号，则输出?-右符号；如果缺少...
profinet协议栈源码
最新发布
05-16
标题"profinet协议栈源码"指的是这个项目是关于PROFINET通信协议的软件实现，其核心是协议栈的源代码。PROFINET是一种基于以太网技术的工业自动化网络标准，由德国西门子公司发起，广泛应用于制造业自动化领域。 ...
栈面试题 ---- 1.元素出栈、入栈顺序的合法性。如入栈的序列（1，2，3，4，5），出栈序列为（4，5，3，2，1） 2.一个数组实现两个栈（共享栈）
阿巴卡的博客
08-23 1692
1.元素出栈、入栈顺序的合法性。如入栈的序列（1，2，3，4，5），出栈序列为（4，5，3，2，1） 思路: 1.将序列存入数组，刚开始栈空将序列中第一个元素入栈，数组下标向后移 2.判断栈顶元素与出栈序列是否相等，相等将栈顶元素Pop，出栈序列下标后移。不相等重复1.2 3.循环1，2直到遍历超出入栈序列范围返回不合法，或者出栈序列遍历完返回合法 代码： int IsStackVal...
7-2 符号配对 (20分)
hhhequation的博客
09-28 3081
7-2 符号配对 (20分) 请编写程序检查C语言源程序中下列符号是否配对：/与/、(与)、[与]、{与}。 输入格式: 输入为一个C语言源程序。当读到某一行中只有一个句点.和一个回车的时候，标志着输入结束。程序中需要检查配对的符号不超过100个。 输出格式: 首先，如果所有符号配对正确，则在第一行中输出YES，否则输出NO。然后在第二行中指出第一个不配对的符号：如果缺少左符号，则输出?-右符号；如果缺少右符号，则输出左符号-?。 #include <bits/stdc++.h> using n
7-2 符号配对
懒羊羊的梦想
10-02 2345
7-2 符号配对 (20 分) 请编写程序检查C语言源程序中下列符号是否配对：/与/、(与)、[与]、{与}。 输入格式: 输入为一个C语言源程序。当读到某一行中只有一个句点.和一个回车的时候，标志着输入结束。程序中需要检查配对的符号不超过100个。 输出格式: 首先，如果所有符号配对正确，则在第一行中输出YES，否则输出NO。然后在第二行中指出第一个不配对的符号：如果缺少左符号，则输出?-右符号...
栈堆及例题：整数1,2,3,4,5依次进栈，最后都出栈，可能的出栈序列
Judy_qiudie
03-08 1万+
一、堆 可以看成是一棵树，堆是一棵完全二叉树；将根节点最大的堆叫做最大堆，根节点最小的堆叫做最小堆。 堆是在程序运行时（而不是在编译时），申请某个大小的内存空间，即动态分配内存； 内存由程序员分配释放，若不释放，程序结束由OS回收。 二、队列 队列是一种特殊的线性表，只允许在表的前端进行删除，在表后插入，先进先出。 三、栈（Stack） 又名堆栈，它是一种运算受限的数据结构。仅允许在...
浅析栈区和堆区内存分配的区别
09-05
栈区和堆区是编程语言中内存管理的两个重要概念，它们在内存分配和管理上有显著的区别。首先，栈区，也称为栈，是编译器自动分配和释放的内存区域，主要用于存放函数参数值和局部变量。栈的内存分配是连续的，就像一...
Stack-栈实例
10-23
栈是一种特殊的线性数据结构，遵循“后进先出”（LIFO）的原则。在计算机科学中，栈常被用于解决各种问题，如表达式求值、递归、内存管理等。下面我们将深入探讨栈的基本概念、静态栈与链表栈的实现方式，以及它们在...
两个栈空间共享，栈满打印
04-16
标题中的“两个栈空间共享，栈满打印”指的是在C++编程中实现一个特殊的栈结构，其中两个栈共享同一个内存空间。这个结构可以用于存储整数序列中的奇数和偶数，当任一栈达到其最大容量（即“栈满”状态）时，程序会...
顺序栈代码
06-06
顺序栈是一种常见的数据结构，它在内存中按照线性顺序存储元素，操作主要集中在栈顶进行，遵循“后进先出”（LIFO）的原则。顺序栈通常使用数组或者链表来实现，这里我们主要讨论使用数组实现的顺序栈。 在计算机...
一本通数据结构——栈的习题，很全，希望您能喜欢
08-10
《一本通数据结构——栈的习题》可能涵盖了栈的各种基础和进阶问题，旨在帮助学习者深入理解栈的原理和应用。通过这些习题，你可以掌握以下知识点： 1. **栈的基本操作**：了解栈的两个基本操作，即入栈（Push）和...
栈运算_栈运算_perhapswcl_
10-02
栈是一种特殊的线性数据结构，它的特点是“后进先出”（Last In First Out，简称LIFO）。在栈中，最新添加的元素（称为“顶”或“栈顶元素”）是最早被移除的。栈在计算机科学中广泛应用，特别是在算法、数据结构和...
顺序栈实现
05-27
顺序栈是一种特殊的线性数据结构，它遵循“后进先出”（LIFO）的原则，即最后进入的元素最先离开。在计算机科学中，栈常用于执行表达式求值、括号匹配、函数调用、内存管理等多种任务。C++ 是一种通用的编程语言，以...
栈的顺序存储结构C实现
02-05
1. 创建栈：创建一个新的顺序栈通常涉及到分配一段内存空间，用于存储栈中的元素。在C语言中，可以使用`malloc`或`calloc`函数动态分配内存。 ```c typedef struct { int* data; // 存储栈元素的数组 int top; //...
【数据结构实验】栈的应用
06-15
实验三 栈的应用 1.实验目的： 熟悉栈的定义，栈的特点以及栈的基本操作。能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 对任意给定的一个中缀算术表达式,输出等价的后缀形式。
结合实例理解栈的入栈序列1，2，3，4，5，则栈的输出序列是()问题
热门推荐
流苏的博客
10-17 2万+
理解一个栈的入栈序列 1，2，3，4，5，栈输出序列问题 数据结构——栈问题 如何理解这种序列问题呢？且看下文： 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。（参考：百度百科） 怎么理解栈顶 栈底？ 把栈看做一个箱子，依次放入五本书，依次为甲乙丙丁戊 简要理解： 栈顶为最后进的元素，也就是最后放的戊书 栈底为最先进的元素，也就是最先放的甲书 栈的出栈原则？ “后进先出”或者“先进后出” 结合例子加以理解： 假如将入
入栈顺序为1，2，3，4，5出栈顺序不可能的顺序是什么
shanglizhangrui的专栏
10-31 9944
本人理解的最重要的一点就是，入栈时
设线性表、堆栈、队列的主要区别是什么？一个堆栈的入栈顺序是1、2、3、4、5。若第一个出栈的元素是4，则最后一个出栈的元素必定是
04-29
线性表、堆栈、队列都是数据结构中的基础数据类型，它们的主要区别在于数据的存储和操作方式。 线性表是一种数据结构，其数据元素按照线性顺序排列，可以通过下标访问元素。 堆栈是一种特殊的线性表，只能在一端进行插入和删除操作，即后进先出（LIFO）。 队列也是一种特殊的线性表，只能在两端进行插入和删除操作，即先进先出（FIFO）。 如果一个堆栈的入栈顺序是1、2、3、4、5，而第一个出栈的元素是4，则最后一个出栈的元素必定是1。因为堆栈的特性是后进先出，所以在4出栈后，下一个出栈的元素是3，然后是2，最后是1。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值