考研408之栈与队列学习

最近我系统学习了栈和队列的数据结构，现将实现代码分享如下：

1. 顺序栈实现

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>// 顺序栈定义
#define maxsize 50
typedef int elemtype;
typedef struct {elemtype data[maxsize];  // 存储栈元素的数组int top;                 // 栈顶指针
}sqstack;// 初始化栈
void init_stack(sqstack& S)
{S.top = -1;  // 栈顶指针初始化为-1表示空栈
}// 判断栈是否为空
bool stack_empty(sqstack S)
{if (S.top == -1){return true;}else{return false;}
}// 入栈操作
void push(sqstack& S, elemtype num)
{if (S.top == maxsize - 1)  // 栈满检查{return;}else{S.data[++S.top] = num;  // 栈顶指针先加1再存入元素}
}// 获取栈顶元素
bool get_top(sqstack S, elemtype &m)
{bool flag = stack_empty(S);if (flag){return false;}m = S.data[S.top];  // 获取栈顶元素但不弹出return true;
}// 出栈操作
bool pop_stack(sqstack &S, elemtype & m)
{bool flag = stack_empty(S);if (flag){return false;}m = S.data[S.top--];  // 先取出栈顶元素再将指针减1return true;
}int main()
{sqstack S;init_stack(S);bool flag;flag = stack_empty(S);if (flag){printf("stack is empty\n");}push(S, 3);push(S, 5);push(S, 6);elemtype m = 0;flag = get_top(S, m);if (flag){printf("S.top is %d\n", m);}flag = pop_stack(S,m);if (flag){printf("原栈顶元素%-2d已经被弹出",m);}return 0;
}

2. 循环队列实现

// 循环队列实现
#define maxsize 5  // 队列容量为4，留一个位置判断队满
typedef int elemtype;
typedef struct sq_queue{elemtype data[5];  // 存储队列元素的数组int rear;          // 队尾指针int front;         // 队头指针
}sq_queue;// 初始化队列
void init_queue(sq_queue &Q)
{Q.rear = Q.front = 0;  // 队头和队尾指针都初始化为0
}// 判断队列是否为空
bool if_emepty(sq_queue Q)
{if (Q.front == Q.rear){return true;}return false;
}// 入队操作
bool in_queue(sq_queue *Q, elemtype num)
{if (Q->front == (Q->rear + 1) % maxsize)  // 判断队列是否已满{return false;}Q->data[Q->rear] = num;Q->rear = (Q->rear + 1) % maxsize;  // 循环移动队尾指针return true;
}// 出队操作
bool de_queue(sq_queue& Q, elemtype& m)
{bool ret = if_emepty(Q);if (ret){return false;}m = Q.data[Q.front];Q.front = (Q.front + 1) % maxsize;  // 循环移动队头指针return true;
}int main()
{sq_queue Q;init_queue(Q);bool ret = if_emepty(Q);if (ret){printf("循环队列初始化成功");}in_queue(&Q, 1);in_queue(&Q, 2);in_queue(&Q, 3);ret = in_queue(&Q, 4);if(ret){printf("插入成功\n");}else {printf("插入失败\n");}ret = in_queue(&Q, 5);if (ret) {printf("插入成功\n");}else {printf("插入失败\n");}elemtype m = 0;ret = de_queue(Q,m);if (ret){printf("元素%-2d已出队",m);}else{printf("队列为空");}return 0;
}

3. 链式队列实现

// 链式队列实现
typedef int elemtype;
typedef struct Lnode{elemtype data;          // 数据域struct Lnode* next;     // 指针域
}Lnode;typedef struct
{Lnode* rear, *front;    // 队头和队尾指针
}sq_queue;// 初始化链式队列
void init_queue(sq_queue& Q)
{Q.front=Q.rear = (Lnode*)malloc(sizeof(Lnode));  // 创建头结点Q.front->next = NULL;
}// 判断队列是否为空
bool is_empty(sq_queue Q)
{if (Q.front == Q.rear){return true;}return false;
}// 入队操作
void en_queue(sq_queue &Q, elemtype num)
{Lnode* s = (Lnode*)malloc(sizeof(Lnode));s->data = num;s->next = NULL;Q.rear->next = s;  // 将新结点链接到队尾Q.rear = s;        // 更新队尾指针
}// 出队操作
bool de_queue(sq_queue &Q,elemtype &x)
{bool ret = is_empty(Q);if (ret){return false;}Lnode* s = Q.front->next;  // 获取队头元素Q.front->next = s->next;x = s->data;if (s == Q.rear)  // 如果出队的是最后一个元素{Q.rear = Q.front;  // 将队列置为空}free(s);  // 释放结点内存return true;
}int main()
{sq_queue Q;init_queue(Q);bool ret = is_empty(Q);if (ret){printf("Q is empty\n");}en_queue(Q, 2);en_queue(Q, 3);elemtype x = 0;ret = de_queue(Q,x);if (ret){printf("de_queue success.num = %d",x);}return 0;
}

4. 链表实现的循环队列

// 链表实现的循环队列
typedef int elemtype;
typedef struct node {elemtype data;          // 数据域struct node* next;      // 指针域
}node;typedef struct {node* front, * rear;    // 队头和队尾指针
}cir_queue;// 初始化循环队列
void init(cir_queue &Q)
{Q.front = Q.rear = (node*)malloc(sizeof(node));  // 创建头结点Q.rear->next = Q.front;  // 形成循环
}// 判断队列是否已满
bool is_full(cir_queue Q)
{if (Q.rear->next == Q.front){return true;}return false;
}// 入队操作
void en_queue(cir_queue& Q, elemtype num)
{bool ret = is_full(Q);if (ret)  // 队列已满，需要扩容{node* pnew;pnew = (node*)malloc(sizeof(node));Q.rear->data = num;Q.rear->next = pnew;pnew->next = Q.front;Q.rear = pnew;}else{  // 队列未满，直接插入Q.rear->data = num;Q.rear = Q.rear->next;}
}// 出队操作
bool de_queue(cir_queue& Q, elemtype& num)
{if (Q.rear == Q.front)  // 队列为空{return false;}num = Q.front->data;Q.front->data = NULL;Q.front = Q.front->next;return true;
}int main()
{cir_queue Q;init(Q);is_full(Q);en_queue(Q, 1);en_queue(Q, 2);en_queue(Q, 3);elemtype x = 0;bool ret = de_queue(Q,x);if (ret){printf("%d is be deleted\n", x);}else {printf("the queue is empty\n");}
}

5. 栈和队列综合练习

// 栈和队列综合练习
#include<stdio.h>
#include<stdlib.h>
#define maxsize 5
typedef int elemtype;// 顺序栈定义
typedef struct node {elemtype data[50];int top;
}node;// 循环队列定义
typedef struct sq_queue {elemtype data[maxsize];int front, rear;
}sq_queue;// 栈初始化
void init(node &S)
{S.top = -1;
}// 栈入栈操作
void en_S(node &S)
{elemtype x;for (int i = 0; i < 3; i++){scanf("%d", &x);S.data[++S.top] = x;  // 先移动指针再存入元素}
}// 栈出栈操作
void de_S(node &S)
{while (S.top != -1){printf("%2d", S.data[S.top--]);  // 先取出元素再移动指针}printf("\n");
}// 队列初始化
void init_queue(sq_queue &Q)
{Q.front = Q.rear = 0;
}// 队列入队操作
void en_queue(sq_queue &Q)
{elemtype x;for (int i = 0; i < 5; i++){if ((Q.rear + 1) % maxsize == Q.front)  // 队满检查{printf("false\n");return;}scanf("%d", &x);Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % maxsize;  // 循环移动队尾指针}
}// 队列出队操作
void de_queue(sq_queue Q)
{while (Q.rear != Q.front){printf("%2d", Q.data[Q.front]);Q.front = (Q.front + 1) % maxsize;  // 循环移动队头指针}
}int main()
{node S;  // 新建一个栈init(S);en_S(S);de_S(S);sq_queue Q;init_queue(Q);  // 新建一个循环队列en_queue(Q);de_queue(Q);return 0;
}