2022年王道数据结构考研复习指导习题代码（栈和队列）

3.1栈
1.写出一个算法，判定所给的操作序列是否合法。若合法，返回true，否则返回false（假定被判定的操作序列已存入一维数组中）。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>const int maxn = 100;char A[maxn];bool Judge(char *A)
{int i, k = 0;for (int i = 0; i < strlen(A); i++) {if (k < 0) return false;if (A[i] == 'I') k++;if (A[i] == 'O') k--;}if (k != 0) return false;return true;
}int main()
{scanf("%s", A);if (Judge(A)) printf("yes\n");else printf("no\n");return 0;
}

2.设单链表的表头指针为L，结点结构由data和next两个域构成，其中data域为字符型，试设计算法判断该链表的全部n个字符是否中心对称。

#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;typedef char ElemType;typedef struct LNode {ElemType data;struct LNode *next;
} LNode, *LinkList;int n;LinkList Tail_Insert(LinkList L, int n)
{L = (LinkList)malloc(sizeof(LNode));LNode *s, *r = L;ElemType x;for (int i = 0; i < n; i++) {s = (LinkList)malloc(sizeof(LNode));cin >> x;s->data = x;r->next = s;r = s;}r->next = NULL;return L;
}bool dc(LinkList L, int n)
{int i;char s[n / 2];LNode *p = L->next;for (i = 0; i < n / 2; i++) {s[i] = p->data;p = p->next;}i--;if (n % 2 == 1) p = p->next;while (p != NULL && s[i] == p->data) {i--;p = p->next;}if (i == -1) return true;else return false;
}int main()
{cin >> n;LinkList L = NULL;L = Tail_Insert(L, n);if (dc(L, n)) cout << "yes" << endl;else cout << "no" << endl;return 0;
}

5.设有两个栈s1、s2都采用顺序栈方式，并共享一个存储区[0,…,maxsize - 1]，为了尽量利用空间，减少溢出的可能，可采用栈顶结构，迎面增长的存储方式，试设计s1、s2有关入栈和出栈的操作算法。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>#define maxsize 100#define elemtp inttypedef struct {elemtp stack[maxsize];int top[2];
} stk;stk s;int push(int i, elemtp x)
{if (i < 0 || i > 1) {printf("栈号输入不对\n");exit(0);}if (s.top[1] - s.top[0] == 1) {printf("栈已满\n");return 0;}switch (i) {case 0: s.stack[++s.top[0]] = x; return 1; break;case 1: s.stack[++s.top[1]] = x; return 1;}
}elemtp pop(int i)
{if (i < 0 || i > 1) {printf("栈号输入错误\n");exit(0);}switch (i) {case 0:if (s.top[0] == -1) {printf("栈空\n");return -1;} elsereturn s.stack[s.top[0]--];case 1:if (s.top[1] == maxsize) {printf("栈空\n");return -1;} elsereturn s.stack[s.top[1]++];}
}int main()
{push(0, 3);printf("%d\n", pop(0));push(1, 6);printf("%d\n", pop(1));return 0;
}

3.2队列
1.若希望循环队列中的元素都能得到利用，则需设置一个标志域tag，并以tag的值为0或1来区分队头指针front和队尾指针rear相同时队列状态是“空”还是“满”。试编写与此结构相应的入队和出队算法。

#include <iostream>
using namespace std;#define MaxSize 50typedef int ElemType;typedef struct {ElemType data[MaxSize];int front, rear;int tag;
} SqQueue;void InitQueue(SqQueue &Q)
{Q.rear = Q.front = 0;Q.tag = 0;
}bool isEmpty(SqQueue Q)
{return Q.rear == Q.front;
}bool EnQueue(SqQueue &Q, ElemType x)
{if (Q.front == Q.rear && Q.tag == 1) return false;Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % MaxSize;Q.tag = 1;return true;
}bool DeQueue(SqQueue &Q, ElemType &x)
{if (Q.front == Q.rear && Q.tag == 0) return false;x = Q.data[Q.front];Q.front = (Q.front + 1) % MaxSize;Q.tag = 0;return true;
}int main()
{SqQueue Q;InitQueue(Q);if (EnQueue(Q, 1)) cout << "insert success!" << endl;else cout << "insert fail!" << endl;int ans = 0;if (DeQueue(Q, ans)) cout << "delete success!" << endl;else cout << "delete fail!" << endl;cout << ans << endl;return 0;
}

2.Q是一个队列，S是一个空栈，实现将队列中的元素逆置的算法。

#include <cstring>
#include <iostream>
using namespace std;const int MaxSize = 100;typedef int ElemType;typedef struct {ElemType data[MaxSize];int top;
} SqStack;typedef struct {ElemType data[MaxSize];int front, rear;
} SqQueue;void InitStack(SqStack &S)
{S.top = -1;
}void InitQueue(SqQueue &Q)
{Q.front = Q.rear = 0;
}bool StackEmpty(SqStack S)
{return S.top == -1;
}bool QueueEmpty(SqQueue Q)
{return Q.front == Q.rear;
}bool EnQueue(SqQueue &Q, ElemType x)
{if ((Q.rear + 1) % MaxSize == Q.front) return false;Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % MaxSize;return true;
}bool DeQueue(SqQueue &Q, ElemType &x)
{if (Q.rear == Q.front) return false;x = Q.data[Q.front];Q.front = (Q.front + 1) % MaxSize;return true;
}bool Push(SqStack &S, ElemType x)
{if (S.top == MaxSize - 1) return true;S.data[++S.top] = x;return true;
}bool Pop(SqStack &S, ElemType &x)
{if (S.top == -1) return false;x = S.data[S.top--];return true;
}void turn(SqQueue &Q, SqStack &S)
{int tmp;while (!QueueEmpty(Q)) {DeQueue(Q, tmp);Push(S, tmp);}while (!StackEmpty(S)) {Pop(S, tmp);EnQueue(Q, tmp);}
}int main()
{SqStack S;InitStack(S);SqQueue Q;InitQueue(Q);int n, x;cin >> n;for (int i = 0; i < n; i++) {cin >> x;EnQueue(Q, x);}turn(Q, S);int tmp;while (!QueueEmpty(Q)) {DeQueue(Q, tmp);cout << tmp << " ";}cout << endl;return 0;
}

3.利用两个栈S1，S2来模拟一个队列。

#include <cstring>
#include <iostream>
using namespace std;const int MaxSize = 100;typedef int ElemType;typedef struct {ElemType data[MaxSize];int top;
} SqStack;void InitStack(SqStack &S)
{S.top = -1;
}bool StackEmpty(SqStack S)
{return S.top == -1;
}bool StackOverflow(SqStack S)
{return S.top == MaxSize - 1;
}bool Push(SqStack &S, ElemType x)
{if (S.top == MaxSize - 1) return true;S.data[++S.top] = x;return true;
}bool Pop(SqStack &S, ElemType &x)
{if (S.top == -1) return false;x = S.data[S.top--];return true;
}bool EnQueue(SqStack &S1, SqStack &S2, ElemType x)
{if (!StackOverflow(S1)) {Push(S1, x);return true;}if (StackOverflow(S1) && !StackEmpty(S2)) {cout << "队列满" << endl;return false;}int e;if (StackOverflow(S1) && StackEmpty(S2)) {Pop(S1, e);Push(S2, e);}Push(S1, x);return true;
}void DeQueue(SqStack &S1, SqStack &S2, ElemType &x)
{if (!StackEmpty(S2)) {Pop(S2, x);} else if (StackEmpty(S1)) {cout << "队列为空" << endl;} else {while (!StackEmpty(S1)) {Pop(S1, x);Push(S2, x);}Pop(S2, x);}
}bool QueueEmpty(SqStack S1, SqStack S2)
{return StackEmpty(S1) && StackEmpty(S2);
}int main()
{SqStack S1, S2;InitStack(S1); InitStack(S2);EnQueue(S1, S2, 3);EnQueue(S1, S2, 5);int ans = 0;DeQueue(S1, S2, ans);cout << ans << endl;return 0;
}

4.设计一个队列，要求满足：初始时队列为空；入队时，允许增加队列占用空间；出队后，出队元素所占用的空间可重复使用，即整个队列所占用的空间只增不减；入队操作和出队操作的时间复杂度始终保持为O(1)O(1)O(1)。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>typedef int ElemType;struct LinkNode {ElemType data;struct LinkNode *next;
};typedef struct LinkNode LinkNode;typedef struct {struct LinkNode *front, *rear;
} LinkQueue;void InitQueue(LinkQueue &Q)
{LinkNode *Node = (LinkNode *)malloc(sizeof(LinkNode));Node->next = Node;Q.front = Q.rear = Node;
}void EnQueue(LinkQueue &Q, ElemType x)
{LinkNode *Node = Q.rear;if (Q.front == Q.rear->next) {Node = (LinkNode *)malloc(sizeof(LinkNode));Q.rear->next = Node;Node->next = Q.front;}Q.rear->data = x;Q.rear = Q.rear->next;
}void DeQueue(LinkQueue &Q, ElemType &x)
{if (Q.front == Q.rear) return;x = Q.front->data;Q.front = Q.front->next;
}int main()
{LinkQueue Q;InitQueue(Q);EnQueue(Q, 3);EnQueue(Q, 1);int tmp1 = 0, tmp2 = 0;DeQueue(Q, tmp1); DeQueue(Q, tmp2);printf("%d %d\n", tmp1, tmp2);return 0;
}

3.3栈和队列的应用
1.假设一个算术表达式中包含圆括号、方括号和花括号3种类型的括号，编写一个算法判别表达式中的括号是否配对，以字符”\0”作为算术表达式的结束符。

#include <stack>
#include <iostream>
using namespace std;const int maxn = 100;stack<char> st;char s[maxn];bool judge(char *s)
{for (int i = 0; s[i] != '\0'; i++) {if (s[i] == ')') {if (st.empty() || st.top() != '(') return false;st.pop();} else if (s[i] == ']') {if (st.empty() || st.top() != '[') return false;st.pop();} else if (s[i] == '}') {if (st.empty() || st.top() != '{') return false;st.pop();} else {st.push(s[i]);}}return st.empty();
}int main()
{cin >> s;if (judge(s)) cout << "yes" << endl;else cout << "no" << endl;return 0;
}

2.火车调度站有一个用于调度的“栈道”，火车调度站的入口处有n节硬座和软座车厢（分别用H和S表示）等待调度，试编写算法，输出对这n节车厢进行调度的操作序列，以使所有的软座车厢都被调整到硬座车厢之前。

#include <stack>
#include <iostream>
using namespace std;const int maxn = 100;char s[maxn];stack<char> st;void Train_Arrange(char *train)
{char *p = train, *q = train, c;while (*p) {if (*p == 'H') st.push(*p);else *(q++) = *p;p++;}while (!st.empty()) {*(q++) = st.top();st.pop();}
}int main()
{int n;cin >> n;for (int i = 0; i < n; i++) cin >> s[i];Train_Arrange(s);for (int i = 0; s[i] != '\0'; i++) cout << s[i];cout << endl;return 0;
}

3.利用一个栈实现以下递归函数的非递归计算：
Pn(x)={1,n=02x,n=12xPn−1(x)−2(n−1)Pn−2(x),n>1P_{n}(x)=\left\{ \begin{array}{lcr} 1,&{n = 0}\\ 2x,&{n = 1}\\ 2xP_{n-1}(x)-2(n-1)P_{n-2}(x),&{n > 1} \end{array} \right. Pn(x)=⎩⎨⎧1,2x,2xPn−1(x)−2(n−1)Pn−2(x),n=0n=1n>1

#include <stdio.h>
#include <string.h>
#include <stdlib.h>#define MaxSize 200double p(int n, double x)
{struct stack {int no;double val;} st[MaxSize];int top = -1, i;double fv1 = 1, fv2 = 2 * x;for (i = n; i >= 2; i--) {top++;st[top].no = i;}while (top >= 0) {st[top].val = 2 * x * fv2 - 2 * (st[top].no - 1) * fv1;fv1 = fv2;fv2 = st[top].val;top--;}if (n == 0) return fv1;return fv2;
}int main()
{int n;double x;scanf("%d%lf", &n, &x);double ans = p(n, x);printf("%lf\n", ans);return 0;
}

4.某汽车轮渡口，过江渡船每次能载10辆车过江。过江车辆分为客车类和货车类，上渡船有如下规定：同类车先到先上船；客车优于货车上船，且每上4辆客车，才允许放上1辆货车；若等待客车不足4辆，则以货车代替；若无货车等待，允许客车都上船。试设计一个算法模拟渡口管理。

#include <queue>
#include <iostream>
using namespace std;queue<char> q, q1, q2;void init(queue<char> &q, char *s)
{for (int i = 0; s[i] != '\0'; i++)q.push(s[i]);
}void manager()
{int i = 0, j = 0;while (j < 10) {if (!q1.empty() && i < 4) {q.push(q1.front());q1.pop();i++;j++;} else if (i == 4 && !q2.empty()) {q.push(q2.front());q2.pop();j++;i = 0;} else {while (j < 10 && i < 4 && !q2.empty()) {q.push(q2.front());q2.pop();i++;j++;}i = 0;}if (q1.empty() && q2.empty()) j = 11;}
}int main()
{char s1[10], s2[10];cin >> s1; cin >> s2;init(q1, s1); init(q2, s2);manager();while (!q.empty()) {cout << q.front();q.pop();}cout << endl;return 0;
}

2022年王道数据结构考研复习指导习题代码（栈和队列）相关推荐

2019数据结构考研复习指导习题代码（王道论坛）
2019数据结构考研复习指导习题代码(王道论坛) 1.从顺序表删除具有最小值的元素(假设唯一)并由函数返回被删除元素的值.空出的位置由最后一个元素补充,若顺序表为空则显示出错信息并退出运行. bool ...
2023王道数据结构考研习题汇总
2023王道数据结构考研复习习题汇总目录文章目录 2023王道数据结构考研复习习题汇总目录第2章:线性表 2.2线性表的顺序表示-综合应用题(基础题1-9) 2.2线性表的顺序表示-综合应用题(4 ...
研大考研：2015西医综合考研复习指导
研大考研:2015西医综合考研复习指导西医综合复习技巧 1.了解考点:十几年来,考试范围的变化并不大.要认真的归纳总结过去的真题,所有的考点,就会跃然纸上.通过总结我们发现,有许多试题,在不同的年份 ...
数据结构和算法（03）---栈和队列（c++）
文章目录目录一.栈 1.栈的基本操作 2.使用C++模板类实现栈二.队列 1.队列的基本操作 2.循环队列 **循环队列顺序存储** **循环队列链式存储** 3.双端队列目录数据结构: 逻 ...
22考研计算机专业课——数据结构【❤️考研复习指导❤️】
本次复习指导是基于我在21考研初试中我的王道考研数据结构这本书,加上[数据结构与算法设计]这本教材,书上和笔记本上都记满了笔记和重难点,所以在此回顾这些基本知识点,不能做到我当时的面面俱到,但是尽量完 ...
数据结构--顺序表、链表、栈、队列、树、文件（visual studio可运行）
顺序表的顺序存储(增删查) #include <stdio.h> #include <stdlib.h> #define MaxSize 50 typedef int Elem ...
数据结构：线性数据结构（3）-deques（栈，队列，deques, 列表）
deque(也称为双端队列)是与队列类似的项的有序集合.即使 deque 可以拥有栈和队列的许多特性,它不需要由那些数据结构强制的 LIFO 和 FIFO 排序.这取决于你如何持续添加和删除操作. 1 ...
Python数据结构与算法（二）栈和队列
本系列总结了python常用的数据结构和算法,以及一些编程实现. 参考书籍:<数据结构与算法 Python语言实现> [美]Michael T.Goodrich, Roberto Tama ...
数据结构导论【三】之栈、队列和数组
感谢内容提供者:金牛区吴迪软件开发工作室接上一篇:数据结构导论[二]之线性表文章目录一.栈 1.栈的基本概念 ①定义 ②示意图 ③栈的特点 - 后进先出 ④栈的基本操作 ⑤栈的基本运算 2.栈 ...

2022年王道数据结构考研复习指导习题代码（栈和队列）

2022年王道数据结构考研复习指导习题代码（栈和队列）相关推荐

最新文章

热门文章