【数据结构】栈和队列（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]=3

Stack[0]=1
Stack[1]=2

2

队列的顺序存储结构

#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]=3

number=3
Queue[1]=2
Queue[2]=3

2

队列的链式存储结构

#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