DS_Stack

102101222_张凯权

已于 2023-12-04 11:10:49 修改

阅读量1.2k

点赞数

分类专栏： PTA 文章标签：数据结构

于 2022-09-17 18:01:34 首次发布

本文链接：https://blog.csdn.net/m0_61758697/article/details/126892397

版权

PTA 专栏收录该内容

45 篇文章 10 订阅

订阅专栏

1-1

若一个栈的输入序列为1，2，3，…，N，输出序列的第一个元素是i，则第j个输出元素是j−i−1。

1-2

序列{1,2,3,4,5}依次入栈，则不可能得到{3,4,1,2,5}的出栈序列。

1-3

栈结构不会出现溢出现象。

1-4

两个栈共享一片连续空间，可以将两个栈的栈底分别设在这片空间的两端。

1-5

堆栈适合解决处理顺序与输入顺序相同的问题。

2-1

若一个栈的入栈序列为1、2、3、…、N，输出序列的第一个元素是i，则第j个输出元素是：

A.i−j−1

B.i−j

C.j−i−1

D.不确定

2-2

若一个栈的入栈序列为1、2、3、…、N，其输出序列为p1、p2、p3、…、pN。若p1=N，则pi为：

A.i

B.n−i

C.n−i+1

D.不确定

2-3

将5个字母ooops按此顺序入栈，则有多少种不同的出栈顺序可以仍然得到ooops？

A.1

B.3

C.5

D.6

2-4

若借助堆栈将中缀表达式a+b*c+(d*e+f)*g转换为后缀表达式，当读入f时，堆栈里的内容是什么（按堆栈自底向上顺序）？

A.+(*+

B.+(+

C.++(+

D.abcde

2-5

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

A.1

B.3

C.5

D.1或者5

2-6

利用大小为n的数组（下标从0到n-1）存储一个栈时，假定栈从数组另一头开始且top==n表示栈空，则向这个栈插入一个元素时，修改top指针应当执行：

A.top=0

B.top++

C.top--

D.top不变

2-7

给定一个堆栈的入栈序列为{ 1, 2, ⋯, n }，出栈序列为{ p1, p2, ⋯, pn }。如果p2=n，则存在多少种不同的出栈序列？

A.1

B.2

C.n−1

D.n

2-8

下列关于栈的叙述中，错误的是：

采用非递归方式重写递归程序时必须使用栈
函数调用时，系统要用栈保存必要的信息
只要确定了入栈次序，即可确定出栈次序
栈是一种受限的线性表，允许在其两端进行操作

A.仅 1

B.仅 1、2、3

C.仅 1、3、4

D.仅 2、3、4

2-9

在作进栈运算时，应先判别栈是否(① )；在作退栈运算时应先判别栈是否(② )。当栈中元素为n个，作进栈运算时发生上溢，则说明该栈的最大容量为(③ )。

①: A. 空 B. 满 C. 上溢 D. 下溢

②: A. 空 B. 满 C. 上溢 D. 下溢

③: A. n-1 B. n C. n+1 D. n/2

A.① C ② D ③ B

B.① B ② A ③ B

C.① B ② B ③ A

D.① B ② A ③ A

2-10

设有一顺序栈S，元素s1,s2,s3,s4,s5,s6依次进栈，如果6个元素出栈的顺序是s2,s3,s4, s6 , s5,s1,则栈的容量至少应该是( )。

A.2

B.3

C.5

D.6

2-11

元素A,B,C,D依次入栈，出栈无限制，则以下（）是可能的出栈序列。

A.C, A, B, D

B.B, A, D, C

C.B, D, A, C

D.A, D, B, C

2-12

用S表示入栈操作，X表示出栈操作，若元素入栈的顺序为1234，为了得到1342出栈顺序，相应的S和X的操作串为( )。

A.SXSSSXXX

B.SXSXSXSX

C.SSSSXXXX

D.SXSSXSXX

2-13

已知普通表达式c/(e-f)*(a+b)，对应的后缀表达式是（）

A.cef/-ab*+

B.ef-c/ab+*

C.cef-/ab+*

D.c/e-f*a+b

2-14

给定有限符号集 S , in 和 out 均为 S 中所有元素的任意排列。对于初始为空的栈 ST, 下列叙述中，正确的是：

A.若 in 是 ST 的入栈序列，则不能判断 out 是否为其可能的出栈序列

B.若 out 是 ST 的出栈序列，则不能判断 in 是否为其可能的入栈序列

C.若 in 是 ST 的入栈序列，out 是对应 in 的出栈序列，则 in 与 out 一定不同

D.若 in 是 ST 的入栈序列，out 是对应 in 的出栈序列，则 in 与 out 可能互为倒序

2-15

检查表达式中的括号是否匹配的问题需要借助________来解决。

A.队列

B.堆栈

C.二叉搜索树

D.有向无环图

6-1 在一个数组中实现两个堆栈

本题要求在一个数组中实现两个堆栈。

函数接口定义：

Stack CreateStack( int MaxSize ); 
bool Push( Stack S, ElementType X, int Tag ); 
ElementType Pop( Stack S, int Tag );

其中Tag是堆栈编号，取1或2；MaxSize堆栈数组的规模；Stack结构定义如下：

typedef int Position;
 struct SNode 
{ 
ElementType *Data; 
Position Top1, Top2; 
int MaxSize; 
};
 typedef struct SNode *Stack;

注意：如果堆栈已满，Push函数必须输出“Stack Full”并且返回false；如果某堆栈是空的，则Pop函数必须输出“Stack Tag Empty”（其中Tag是该堆栈的编号），并且返回ERROR。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

#define ERROR 1e8
typedef int ElementType;
typedef enum { push, pop, end } Operation;
typedef enum { false, true } bool;
typedef int Position;
struct SNode {
    ElementType *Data;
    Position Top1, Top2;
    int MaxSize;
};
typedef struct SNode *Stack;

Stack CreateStack( int MaxSize );
bool Push( Stack S, ElementType X, int Tag );
ElementType Pop( Stack S, int Tag );

Operation GetOp();  /* details omitted */
void PrintStack( Stack S, int Tag ); /* details omitted */

int main()
{
    int N, Tag, X;
    Stack S;
    int done = 0;

    scanf("%d", &N);
    S = CreateStack(N);
    while ( !done ) {
        switch( GetOp() ) {
        case push: 
            scanf("%d %d", &Tag, &X);
            if (!Push(S, X, Tag)) printf("Stack %d is Full!\n", Tag);
            break;
        case pop:
            scanf("%d", &Tag);
            X = Pop(S, Tag);
            if ( X==ERROR ) printf("Stack %d is Empty!\n", Tag);
            break;
        case end:
            PrintStack(S, 1);
            PrintStack(S, 2);
            done = 1;
            break;
        }
    }
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

5
Push 1 1
Pop 2
Push 2 11
Push 1 2
Push 2 12
Pop 1
Push 2 13
Push 2 14
Push 1 3
Pop 2
End

输出样例：

Stack 2 Empty
Stack 2 is Empty!
Stack Full
Stack 1 is Full!
Pop from Stack 1: 1
Pop from Stack 2: 13 12 11

Stack CreateStack( int MaxSize )
{
    Stack s = (struct SNode *)malloc(sizeof(struct SNode));
    s->Data = (int *)malloc(sizeof(ElementType)* MaxSize);
    s->Top1 = -1;
    s->Top2 = MaxSize;
    s->MaxSize = MaxSize;
    return s;
}
bool Push( Stack S, ElementType X, int Tag )
{
    if(S == NULL)
        return false;
    if (S->Top1+1 == S->Top2)//栈满
    {
        printf("Stack Full\n");
        return false;
    }
    if(Tag == 1)
        S->Data[++S->Top1] = X;
     else if(Tag == 2)
         S->Data[--S->Top2] = X;
     return true;
}
ElementType Pop( Stack S, int Tag )
{
    if(S == NULL)
        return ERROR;
    if (Tag == 1)
    {
        if (S->Top1 == -1)
        {
            printf("Stack %d Empty\n",Tag);
            return ERROR;
        }
        return S->Data[S->Top1--];
    }
    else if(Tag == 2)
    {
        if (S->Top2 == S->MaxSize)
        {
            printf("Stack %d Empty\n",Tag);
            return ERROR;
        }
        return S->Data[S->Top2++];
    }
}

7-1 彩虹瓶

彩虹瓶的制作过程（并不）是这样的：先把一大批空瓶铺放在装填场地上，然后按照一定的顺序将每种颜色的小球均匀撒到这批瓶子里。

假设彩虹瓶里要按顺序装 N 种颜色的小球（不妨将顺序就编号为 1 到 N）。现在工厂里有每种颜色的小球各一箱，工人需要一箱一箱地将小球从工厂里搬到装填场地。如果搬来的这箱小球正好是可以装填的颜色，就直接拆箱装填；如果不是，就把箱子先码放在一个临时货架上，码放的方法就是一箱一箱堆上去。当一种颜色装填完以后，先看看货架顶端的一箱是不是下一个要装填的颜色，如果是就取下来装填，否则去工厂里再搬一箱过来。

如果工厂里发货的顺序比较好，工人就可以顺利地完成装填。例如要按顺序装填 7 种颜色，工厂按照 7、6、1、3、2、5、4 这个顺序发货，则工人先拿到 7、6 两种不能装填的颜色，将其按照 7 在下、6 在上的顺序堆在货架上；拿到 1 时可以直接装填；拿到 3 时又得临时码放在 6 号颜色箱上；拿到 2 时可以直接装填；随后从货架顶取下 3 进行装填；然后拿到 5，临时码放到 6 上面；最后取了 4 号颜色直接装填；剩下的工作就是顺序从货架上取下 5、6、7 依次装填。

但如果工厂按照 3、1、5、4、2、6、7 这个顺序发货，工人就必须要愤怒地折腾货架了，因为装填完 2 号颜色以后，不把货架上的多个箱子搬下来就拿不到 3 号箱，就不可能顺利完成任务。

另外，货架的容量有限，如果要堆积的货物超过容量，工人也没办法顺利完成任务。例如工厂按照 7、6、5、4、3、2、1 这个顺序发货，如果货架够高，能码放 6 只箱子，那还是可以顺利完工的；但如果货架只能码放 5 只箱子，工人就又要愤怒了……

本题就请你判断一下，工厂的发货顺序能否让工人顺利完成任务。

输入格式：

输入首先在第一行给出 3 个正整数，分别是彩虹瓶的颜色数量 N（1<N≤103）、临时货架的容量 M（<N）、以及需要判断的发货顺序的数量 K。

随后 K 行，每行给出 N 个数字，是 1 到N 的一个排列，对应工厂的发货顺序。

一行中的数字都以空格分隔。

输出格式：

对每个发货顺序，如果工人可以愉快完工，就在一行中输出 YES；否则输出 NO。

输入样例：

7 5 3
7 6 1 3 2 5 4
3 1 5 4 2 6 7
7 6 5 4 3 2 1

输出样例：

YES
NO
NO

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int N,M,K;
	cin >> N >> M >> K;
	int flag = 0, bj, order;
    for(int i = 0;i < K;i++)
    {
        bj = 1;
        flag = 0;
        stack<int> s;
        for(int j = 0;j < N;j++)
        {
            cin>>order;
            if(order == bj)
            {
                bj++;
                while(!s.empty())
                {
                    if(s.top() == bj)
                    {
                        s.pop();
                        bj++;
                    }
                    else
                        break;
                }
            }
            else
            {
                s.push(order);
                if(s.size() > M)
                    flag = 1;
            }
        }
        if(flag == 0 && bj >= N)
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    
    return 0;
}

102101222_张凯权

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
DS_Stack

其中Tag是堆栈编号，取1或2；MaxSize堆栈数组的规模；Stack{};注意：如果堆栈已满，Push函数必须输出“Stack Full”并且返回false；如果某堆栈是空的，则Pop函数必须输出“Stack Tag Empty”（其中Tag是该堆栈的编号），并且返回ERROR。
复制链接

扫一扫