【数据结构】栈和队列（WD）
栈的顺序存储结构
#include <bits/stdc++.h>
using namespace std;
#define MaxSize 10 //定义栈中元素的最大个数
typedef struct
{
int data[MaxSize]; //静态数组存放栈中元素
int top; //栈顶指针
} SqStack; //Sq:sequence顺序
//初始化栈
void initStack(SqStack &S)
{
S.top = -1; //初始化栈顶指针
}
//判断栈是否为空
bool stackEmpty(SqStack S)
{
if (S.top == -1)
{ //栈空
return true;
}
else
{ //不空
return false;
}
}
//进栈
bool push(SqStack &S, int x)
{
if (S.top == MaxSize - 1)
{ //栈满，报错
return false;
}
S.top++; //指针先加1
S.data[S.top] = x; //新元素入栈
return true;
}
//出栈
bool pop(SqStack &S, int x)
{
if (S.top == -1)
{ //栈空，报错
return false;
}
x = S.data[S.top]; //先出栈
S.top--; //指针再减1
return true;
}
//读栈顶元素
bool getTop(SqStack S, int &x)
{
if (S.top == -1)
{ //栈空，报错
return false;
}
x = S.data[S.top]; //x记录栈顶元素
return true;
}
//打印
void output(SqStack S)
{
for (int i = 0; i <= S.top; i++)
{
printf("Stack[%d]=%d\n", i, S.data[i]);
}
printf("\n");
}
int main()
{
SqStack S; //声明一个顺序栈（分配空间）
initStack(S);
if (stackEmpty(S))
{
push(S, 1);
push(S, 2);
push(S, 3);
output(S);
int x;
pop(S, x);
output(S);
getTop(S, x);
printf("%d\n", x);
}
else
{
printf("failure!\n");
}
return 0;
}
output:
Stack[0]=1
Stack[1]=2
Stack[2]=3Stack[0]=1
Stack[1]=22
队列的顺序存储结构
#include <bits/stdc++.h>
using namespace std;
#define MaxSize 10 //定义队列中元素的最大个数
typedef struct
{
int data[MaxSize]; //用静态数组存放队列元素
int front, rear; //队头指针和队尾指针
} SqQueue;
//初始化队列
void initQueue(SqQueue &Q)
{
//初始时，队头、队尾指针指向0
Q.front = Q.rear = 0;
}
//判断队列是否为空
bool QueueEmpty(SqQueue Q)
{
if (Q.rear == Q.front)
{ //队空条件
return true;
}
else
{
return false;
}
}
//入队
bool EnQueue(SqQueue &Q, int x)
{
if ((Q.rear + 1) % MaxSize == Q.front)
{
return false; //队满则报错
}
Q.data[Q.rear] = x; //新元素插入队尾
Q.rear = (Q.rear + 1) % MaxSize; //队尾指针加1取模
return true;
}
//出队
bool DeQueue(SqQueue &Q,int &x){
if(Q.rear==Q.front){//队空则报错
return false;
}
x=Q.data[Q.front];
Q.front=(Q.front+1)%MaxSize;//队头指针后移
return true;
}
//获得队头元素的值，用x返回
bool GetHead(SqQueue Q,int &x){
if(Q.rear==Q.front){
return false;
}
x=Q.data[Q.front];
return true;
}
//返回队列元素个数
int Count(SqQueue Q){
return (Q.rear+MaxSize-Q.front)%MaxSize;
}
//打印
void output(SqQueue Q){
for(int i=Q.front;i!=Q.rear;i=(i+1)%MaxSize){
printf("Queue[%d]=%d\n",i,Q.data[i]);
}
printf("\n");
}
int main()
{
SqQueue Q; //声明一个队列
initQueue(Q);
if (QueueEmpty(Q))
{
EnQueue(Q,1);
EnQueue(Q,2);
EnQueue(Q,3);
output(Q);
printf("number=%d\n",Count(Q));
int x;
DeQueue(Q,x);
output(Q);
GetHead(Q,x);
printf("%d\n",x);
}
else
{
printf("failure!\n");
}
return 0;
}
output:
Queue[0]=1
Queue[1]=2
Queue[2]=3number=3
Queue[1]=2
Queue[2]=32
队列的链式存储结构
#include <bits/stdc++.h>
using namespace std;
//链式队列结点
typedef struct LinkNode
{
int data;
struct LinkNode *next;
} LinkNode;
//链式队列
typedef struct
{
LinkNode *front, *rear; //队列的队头和队尾指针
} LinkQueue;
//初始化队列(带头结点)
void InitQueue1(LinkQueue &Q)
{
//初始时，front、rear都指向头结点
Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
Q.front->next = NULL;
}
//初始化队列(不带头结点)
void InitQueue2(LinkQueue &Q)
{
//初始时，front、rear都指向NULL
Q.front = NULL;
Q.rear = NULL;
}
//判断队列是否为空(带头结点)
bool IsEmpty1(LinkQueue Q)
{
if (Q.rear == Q.front)
{ //队空条件
return true;
}
else
{
return false;
}
}
//判断队列是否为空(不带头结点)
bool IsEmpty2(LinkQueue Q)
{
if (Q.front == NULL)
{ //队空条件
//也可以判断if (Q.rear == NULL)
return true;
}
else
{
return false;
}
}
//入队(带头结点)
void EnQueue1(LinkQueue &Q, int x)
{
LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
s->data = x;
s->next = NULL;
Q.rear->next = s; //新结点插入到rear之后
Q.rear = s; //修改表尾指针
}
//入队(不带头结点)
void EnQueue2(LinkQueue &Q, int x)
{
LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
s->data = x;
s->next = NULL;
if (Q.front == NULL)
{ //在空队列中插入第一个元素
//修改队头队尾指针
Q.front = s;
Q.rear = s;
}
else
{
Q.rear->next = s;
Q.rear = s;
}
}
//出队(带头结点)
bool DeQueue1(LinkQueue &Q, int &x)
{
if (Q.front == Q.rear)
{ //空队
return false;
}
LinkNode *p = Q.front->next;
x = p->data; //用变量x返回队头元素
Q.front->next = p->next; //修改头结点的next指针
if (Q.rear == p)
{ //此次是最后一个结点出队
Q.rear = Q.front; //修改rear指针
}
free(p); //释放结点空间
return true;
}
//出队(不带头结点)
bool DeQueue2(LinkQueue &Q, int &x)
{
if (Q.front == NULL)
{ //空队
return false;
}
LinkNode *p = Q.front; //p指向此次出队的结点
x = p->data; //用变量x返回队头元素
Q.front = p->next; //修改front指针
if (Q.rear == p)
{ //此次是最后一个结点出队
Q.front = NULL; //front指向NULL
Q.rear = NULL; //rear指向NULL
}
free(p); //释放结点空间
return true;
}
//打印(带头结点)
void output1(LinkQueue Q)
{
LinkNode *p = Q.front->next;
while (p != NULL)
{
if (p->next != NULL)
{
printf("%d->", p->data);
}
else
{
printf("%d", p->data);
}
p = p->next;
}
printf("\n");
}
//打印(不带头结点)
void output2(LinkQueue Q)
{
LinkNode *p = Q.front;
while (p != NULL)
{
if (p->next != NULL)
{
printf("%d->", p->data);
}
else
{
printf("%d", p->data);
}
p = p->next;
}
printf("\n");
}
int main()
{
int x;
LinkQueue Q1;
InitQueue1(Q1);
if (IsEmpty1(Q1))
{
EnQueue1(Q1, 1);
EnQueue1(Q1, 2);
EnQueue1(Q1, 3);
output1(Q1);
DeQueue1(Q1, x);
output1(Q1);
printf("x1=%d\n", x);
}
else
{
printf("failure!\n");
}
LinkQueue Q2;
InitQueue2(Q2);
if (IsEmpty2(Q2))
{
EnQueue2(Q2, 1);
EnQueue2(Q2, 2);
EnQueue2(Q2, 3);
output2(Q2);
DeQueue2(Q2, x);
output2(Q2);
printf("x2=%d\n", x);
}
else
{
printf("failure!\n");
}
return 0;
}
output:
1->2->3
2->3
x1=1
1->2->3
2->3
x2=1
括号匹配
#include <bits/stdc++.h>
using namespace std;
#define MaxSize 10 //定义栈中元素的最大个数
typedef struct {
char data[MaxSize]; //静态数组存放栈中元素
int top; //栈顶指针
} SqStack;
//初始化栈
void initStack(SqStack &S) {
S.top = -1; //初始化栈顶指针
}
//判断栈是否为空
bool stackEmpty(SqStack S) {
if (S.top == -1) {
//栈空
return true;
} else {
//不空
return false;
}
}
//进栈
bool push(SqStack &S, char x) {
if (S.top == MaxSize - 1) {
//栈满，报错
return false;
}
S.top++; //指针先加1
S.data[S.top] = x; //新元素入栈
return true;
}
//出栈
bool pop(SqStack &S, char &x) {
if (S.top == -1) {
//栈空，报错
return false;
}
x = S.data[S.top]; //先出栈
S.top--; //指针再减1
return true;
}
//括号匹配
bool bracketsCheck(char str[], int length) {
SqStack S; //声明一个顺序栈
initStack(S);
for(int i = 0; i < length; i++) {
if(str[i] == '(' || str[i] == '[' || str[i] == '{') {
push(S, str[i]); //扫描到左括号，入栈
} else { //扫描到右括号
if(stackEmpty(S)) { //当前栈空
return false;//匹配失败
}
char topElem;//暂存栈顶元素
pop(S, topElem); //栈顶元素出栈
if(str[i] == ')' && topElem != '(') {
return false;
}
if(str[i] == ']' && topElem != '[') {
return false;
}
if(str[i] == '}' && topElem != '{') {
return false;
}
}
}
return stackEmpty(S);//检索完全部括号后，栈空说明匹配成功
}
int main() {
// char str[10] = {'(', ')', '[', ']', '{', '}'};
char str[10] = {'(', '(',']'};
if(bracketsCheck(str, strlen(str))) {
cout << "success!" << endl;
} else {
cout << "failure!" << endl;
}
return 0;
}
