考研408之栈与队列学习

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

1. 顺序栈实现

cpp 复制代码

#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--];  // 先取出栈顶元素再将指针减1
    return 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. 循环队列实现

cpp 复制代码

// 循环队列实现
#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. 链式队列实现

cpp 复制代码

// 链式队列实现
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. 链表实现的循环队列

cpp 复制代码

// 链表实现的循环队列
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. 栈和队列综合练习

cpp 复制代码

// 栈和队列综合练习
#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;
}