2023数据结构考研复习-栈队列和数组
Posted ZSYL
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了2023数据结构考研复习-栈队列和数组相关的知识，希望对你有一定的参考价值。
2023数据结构考研复习-栈、队列和数组（二）
前言
数据结构考研复习过程中记录部分代码学习，由于考研复习时间紧凑，就没有详细写注释跟笔记，请谅解。
2023考研必胜！
栈
用声明的方式创建栈，没有使用malloc，函数运行结束后会自动回收内存。
栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
顺序栈
#include <iostream>
using namespace std;
#define Maxsize 10
struct Stack
int data[Maxsize];
int top;
;
void init (Stack* s)
s->top = -1;
bool empty (Stack *S)
return S->top == -1;
bool push (Stack &S, int x)
if (S.top == Maxsize-1)
return 0;
S.data[++S.top] = x;
return 1;
bool pop (Stack &S, int &x)
if (S.top == -1)
return 0;
x = S.data[S.top--];
return 1;
bool top (Stack S, int &x)
if (S.top == -1)
return 0;
x = S.data[S.top];
return 1;
int main()
Stack s;
Stack *ss = &s;
init(ss);
cout << empty(ss) << endl;
cout << ss->top << endl;
共享栈
#include <iostream>
using namespace std;
#define Maxsize 10
// 共享栈
struct Stack
int data[Maxsize];
int top0;
int top1;
;
void init (Stack& s)
s.top0 = -1;
s.top1 = Maxsize;
bool empty (Stack S)
return S.top0+1 == S.top1;
bool push (Stack &S, int x, int i)
if (i != 0 || i != 1)
return false;
if (S.top1 - S.top0 == 1)
return 0;
switch(i)
case 0: S.data[++s.top0] = x; return 1; break;
case 1: S.data[--s.top1] = x; return 1;
bool pop (Stack &S, int &x, int i)
if (i != 0 || i != 1)
return false;
switch(i)
case 0:
if (S.top0 == -1)
return 0;
else
return S.data[s.top0--];
break;
case 1:
if (S.top1 == Maxsize)
return 0;
else
return S.data[s.top1++];
break;
bool top (Stack S, int &x, int i)
switch(i)
case 0: return S.data[s.top0]; break;
case 1: return S.data[s.top1]; break;
return -1;
int main()
Stack s;
init(s);
cout << empty(s) << endl;
cout << s.top << endl;
括号匹配
#include <iostream>
using namespace std;
#define Maxsize 10
char c[10010];
int top = -1;
bool bracketCheck (char str[], int length)
for (int i = 0; str[i] != '\\0'; i++)
if (str[i] == '(' || str[i] == '[' || str[i] == '')
c[++top] = str[i];
else
if (top < 0)
return false;
char t = c[top--];
if (str[i] == ')' && t != '(')
return false;
if (str[i] == ']' && t != '[')
return false;
if (str[i] == '' && t != '')
return false;
return top == -1;
int main()
char c[] = "[]";
cout << bracketCheck(c, sizeof(c)) << endl;
函数调用
特点：最后被调用的函数最先执行结束（LIFO）
需要一个栈存储：
- 调用返回地址
- 实参
- 局部变量
进制转换
public static void conversion(int N, int r)
Stack<Integer> stack = new Stack<>();
while (N != 0)
stack.push(N % r);
N = N / r;
System.out.println("进制转化结果是：");
while(!stack.empty())
System.out.print(stack.pop());
队列
顺序存储
#include <iostream>
using namespace std;
#define Maxsize 10
struct Queue
int data[Maxsize];
int front, rear;
int size = 0; // 当前长度，即便队满队空都指向同一个位置
int flag = 0; // 删除都置为0，插入都置为1，因此队满条件: front == rear && tag == 1
;
void init (Queue* s)
s->rear = 0;
s->front = 0;
bool empty (Queue *S)
return S->rear == S->front;
bool add (Queue &S, int x)
// 判断队满
if ((S.rear+1) % Maxsize == S.front)
return 0;
S.data[S.rear] = x;
S.rear = (S.rear + 1) % Maxsize;
return 1;
bool pop (Queue &S, int &x)
if (S.rear == S.front) // 判断队空
return 0;
x = S.data[S.front];
S.front = (S.front + 1) % Maxsize;
return 1;
bool top (Queue S, int &x)
if (S.rear == S.front) // 判断队空
return 0;
x = S.data[S.front];
return 1;
int length (Queue S)
return (S.rear + Maxsize - S.front) % Maxsize;
int main()
Queue s;
Queue *ss = &s;
init(ss);
cout << empty(ss) << endl;
cout << ss->top << endl;
链式存储
#include <iostream>
using namespace std;
#define Maxsize 10
struct Node
int data;
Node *next;
;
struct Queue
Node *front, *rear;
int size = 0; // 当前长度，即便队满队空都指向同一个位置
int flag = 0; // 删除都置为0，插入都置为1，因此队满条件: front == rear && tag == 1
;
void init (Queue &Q)
Q.rear = Q.front = new Node;
Q.front->next = NULL;
bool empty (Queue *Q)
return Q->front == Q->rear || Q->front->next == NULL;
bool add (Queue &Q, int x)
Node *s = new Node;
s->data = x;
s->next = NULL;
Q.rear->next = s;
Q.rear = s; // 修改表尾指针
return 1;
bool pop (Queue &S, int &x)
if (S.rear == S.front) // 判断队空 不带头结点:S.front == NULL
return 0;
Node *p = S.front->next;
x = p->data;
S.front->next = p->next;
if (S.rear == p) // 最后一个元素出队
S.rear = S.front;
delete p;
p = NULL;
return 1;
bool top (Queue &S, int &x)
if (S.rear == S.front) // 判断队空
return 0;
x = S.front->next->data;
return 1;
int main()
Queue s;
init(s);
cout << s->front->next << endl;
稀疏矩阵
//采用三元组结构的系数矩阵
public class Triple
public int x;
public int y;
private double value;
//构造三元组
public Triple(int x, int y, double data)
this.x = x;
this.y = y;
this.value = data;
public double getData()
return value;
//定义稀疏矩阵
class SparseMatrix
public Triple[] datas; //三元组表
//构造三元组的稀疏矩阵
//参数rows,cols表示稀疏的总行数， length 表示矩阵中非零元素的个数
public SparseMatrix(int rows, int cols, int length)
if(length < 1)
datas = new Triple[1]; //构建空的稀疏矩阵
datas[0] = new Triple(0, 0, 0);
else
datas = new Triple[length+1]; //构建非空稀疏矩阵
datas[0] = new Triple(rows, cols, length);
综合应用
1. 合法IO
03．假设以Ⅰ和О分别表示入栈和出栈操作。栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由Ⅰ和О组成的序列，可以操作的序列称为合法序列，否则称为非法序列.
写出一个算法，判定所给的操作序列是否合法。若合法，返回true，否则返回false（假定被判定的操作序列已存入一维数组中)。
bool Judge(char a[])
int cnt = 0, i = 0;
while (a[i] != '/0')
if (a[i] == 'I')
cnt++;
else
cnt--;
if (cnt == 0)
return 1;
else
return 0;
2. 中心对称
04.设单链表的表头指针为L，结点结构由data和next两个域构成，其中data域为字符型。
试设计算法判断该链表的全部n个字符是否中心对称。例如xyx、xyyx都是中心对称。
算法思想：使用栈来判断链表中的数据是否中心对称。让链表的前一半元素依次进栈。在处理链表的后一半元素时，当访问到链表的一个元素后，就从栈中弹出一个元素，两个元素比较，若相等，则将链表中的下一个元素与栈中再弹出的元素比较，直至链表到尾。这时若栈是空栈，则得出链表中心对称的结论;否则，当链表中的一个元素与栈中弹出元素不等时，结论为链表非中心对称。
int dc(LinkList L, int n)
int i;
char s[n/2];
p = L->next;
for (i = 0; i < n/2; i++)
s[i] = p->data;
p = p->next;
if ((i & 1) == 1)
p = p->next;
i--;
while (p && s[i] == p->data)
i--;
p = p->next;
if (i == -1)
return 1;
else
return 0;
3. 共享栈
05．设有两个栈s1、s2都采用顺序栈方式，并共享一个存储区〔0, … maxsize-1]，为了尽量利用空间，减少溢出的可能，可采用栈顶相向、迎面增长的存储方式。试设计s1、s2有关入栈和出栈的操作算法。.
两个栈共享向量空间，将两个栈的栈底设在向量两端，初始时，s1栈顶指针为-1，s2栈顶指针为maxsize。两个栈顶指针相邻时为栈满。两个栈顶相向、迎面增长，栈顶指针指向栈顶元素。
using namespace std;
#define Maxsize 10
// 共享栈
struct Stack
int data[Maxsize];
int top0;
int top1;
;
void init (Stack& s)
s.top0 = -1;
s.top1 = Maxsize;
入栈操作：
bool push (Stack &S, int x, int i)
if (i != 0 || i != 1)
return false;
if (S.top1 - S.top0 == 1)
return 0;
switch(i)
case 0: S.data[++s.top0] = x; return 1; break;
case 1: S.data[--s以上是关于2023数据结构考研复习-栈队列和数组的主要内容，如果未能解决你的问题，请参考以下文章