4.顺序栈和循环队列的基本运算

最新推荐文章于 2023-10-15 14:21:22 发布
最新推荐文章于 2023-10-15 14:21:22 发布
阅读量917 收藏 11
点赞数 4
分类专栏： 数据结构 文章标签： c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53947363/article/details/127212233
版权

顺序栈和循环队列的基本运算

内容

构建顺序栈类型

  • 实现顺序栈的初始化
  • 顺序栈的判满
  • 顺序栈的判空
  • 顺序栈的入栈
  • 顺序栈的出栈
  • 顺序栈的读取栈顶元素
  • 基于顺序栈实现表达式中括号是否匹配的检验

构建循环队列类型

  • 实现循环队列的初始化
  • 循环队列的判满
  • 循环队列的判空
  • 循环队列的入队
  • 循环队列的出队
  • 循环队列的读取队头元素
  • 循环队列的读取队尾元素
  • 基于循环队列实现杨辉三角形N行数据的输出

要求

  • 栈中数据元素的类型统一抽象表示为SElemType类型，在程序中将SElemType类型具体化为char类型
  • 队列中数据元素的类型统一抽象表示为QElemType类型，在程序中将QElemType类型具体化为int类型
  • 将栈的基本运算封装在stack.h和queue.h文件中，源程序直接#include “stack.h”和#include “queue.h”
  • 提交1个源程序文件，而并非提交2个源程序文件

解析

1. 顺序栈

什么是顺序栈？官方的定义：栈(stack)是限定仅在表尾进行插入和删除操作的线性表。允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，不含任何数据元素的栈称为空栈。栈又称为先进后出(Last In First Out)的线性表。
何为栈？何为先进后出，举个例子，手枪的弹匣其实就是一个栈（也是顺序栈），先装入的子弹在弹匣的底部，最后装入的子弹在顶部，每次开枪发射的时候总是打出弹匣顶部的子弹。

1.1. 顺序栈的结构定义
typedef char SElemType;
#define MaxSize 500
typedef struct {
    SElemType data[MaxSize];
    int top;		//栈顶指针
} SqStack;
#### 顺序栈的初始化

```cpp
void InitStack(SqStack *S) {
    for (int i = 0; i < MaxSize; ++i) {
        S->data[i] = '\000';
    }
    S->top = -1;
}
1.2. 顺序栈的判满
bool IsFull(SqStack S) {
    if (S.top == MaxSize - 1)
        return true;
    else
        return false;
}
1.3. 顺序栈的判空
bool IsEmpty(SqStack S) {
    if (S.top == -1)
        return true;
    else return false;
}
1.4. 顺序栈的入栈
bool Push(SqStack *S, SElemType e) {
    if (S->top == MaxSize - 1)    //栈满
        return false;
    S->top++;
    S->data[S->top] = e;    //元素入栈
    return true;
}
1.5. 顺序栈的出栈
bool Pop(SqStack *S, SElemType *e) {
    if (S->top == -1)
        return false;   //栈空
    *e = S->data[S->top];
    S->top--;
    return true;
}
1.6. 顺序栈的读取栈顶元素
SElemType GetTop(SqStack S) {
    return S.data[S.top];
}
1.7. stack.h 文件
//
// Created by Louie on 2022/10/1.
//

typedef char SElemType;
#define MaxSize 500
typedef struct {
    SElemType data[MaxSize];
    int top;
} SqStack;


void InitStack(SqStack *S) {
    for (int i = 0; i < MaxSize; ++i) {
        S->data[i] = '\000';
    }
    S->top = -1;
}

bool IsEmpty(SqStack S) {
    if (S.top == -1)
        return true;
    else return false;
}

bool IsFull(SqStack S) {
    if (S.top == MaxSize - 1)
        return true;
    else
        return false;
}

bool DestroyStack(SqStack *S) {
    if (S->top == -1)
        return false;
    for (int i = 0; i < S->top; ++i) {
        S->data[i] = 0;
    }
    S->top = -1;
    return true;

}

SElemType GetTop(SqStack S) {
    return S.data[S.top];
}

bool Push(SqStack *S, SElemType e) {
    if (S->top == MaxSize - 1)    //栈满
        return false;
    S->top++;
    S->data[S->top] = e;    //元素入栈
    return true;
}

//bool Pop(SqStack *S) {
//    if (S->top == -1)
//        return false;   //栈空
//    S->data[S->top] = '\000';
//    S->top--;
//    return true;
//}
bool Pop(SqStack *S, SElemType *e) {
    if (S->top == -1)
        return false;   //栈空
    *e = S->data[S->top];
    S->top--;
    return true;
}

int StackLength(SqStack S) {
    return (S.top + 1);
}


#ifndef DATASTRUCT_STACK_H
#define DATASTRUCT_STACK_H

#endif //DATASTRUCT_STACK_H
1.8. 基于顺序栈实现表达式中括号是否匹配的检验

arr[] 数组用来存放括号，使用while循环遍历数组，如果是左括号那么就入栈，如果当前的 arr[i] 是右括号，那么就与栈顶元素进行对比，如果正好匹配上如{}、[]、() 那么就将栈顶元素弹出栈顶（类似于消消乐）,考虑到，如果是一组合法的括号序列，那么经过遍历之后顺序栈应该是一个空栈，且栈顶的top == -1 ，如果栈不为空，那么这组括号序列一定是不合法的。具体代码如下

void Match(const char arr[]) {  //括号匹配，arr[]存放所有的括号
    SqStack sqStack;
    InitStack(&sqStack);    //初始化栈
    int i = 0;  //数组arr[]下标
    SElemType e;    //存放栈顶元素
    while (arr[i] != '\000') {   //遍历arr[]数组
        if (arr[i] == '(' || arr[i] == '{' || arr[i] == '[') {
            Push(&sqStack, arr[i]);     //如果是左括号就进栈
        } else if (arr[i] == ')' || arr[i] == '}' || arr[i] == ']') {     //如果匹配到右括号就与栈顶元素进行比较
            switch (arr[i]) {
                case ')':
                    e = GetTop(sqStack);
                    if (e == '(')
                        Pop(&sqStack, &e);      //如果当前的括号与栈顶符号匹配，那么就将栈顶元素压出栈
                    break;
                case ']':
                    e = GetTop(sqStack);
                    if (e == '[')
                        Pop(&sqStack, &e);
                    break;
                case '}':
                    e = GetTop(sqStack);
                    if (e == '{')
                        Pop(&sqStack, &e);
                    break;
            }
        }
        i++;
    }
    if (IsEmpty(sqStack))    //如果栈为空，说明匹配成功
        printf("Bracket matching succeeded!!!\n");
    else
        printf("Bracket matching failed!!!\n");
}
1.8.1. File_Input() 函数

该函数可以从文件里面读取内容，然后对内容进行提取括号，检测文中的括号是否合法。
fopen()里面的第一个参数是目标文件的绝对路径，第二个参数r 表示该文件是只读模式。防止对文件的内容进行修改。

/*
 * 该函数的作用是读取文件，然后筛选出括号并存入arr[]数组中
 */
void File_Input(char arr[]) {
    int ch = 0;
    int count = 0;
    FILE *fp;
    fp = fopen("F:\\DataStruct\\homework\\NO3.cpp ", "r");//test文件的绝对路径
    if (fp == nullptr)
        printf("file is error\n");
    while (ch != EOF) {		//EOF是文件的结束标志
        ch = fgetc(fp);
        if (ch == '(' || ch == ')' || ch == '{' || ch == '}' || ch == '[' || ch == ']')
            arr[count++] = ch;

    }
    fclose(fp);
}

考虑到有些同学对文件操作并不熟悉，为此我提供了终端输入括号序列的方式

1.8.2. Terminal_iInput()函数
void Terminal_iInput(char arr[]) {
    printf("Please enter bracket sequence:\n");
    scanf("%s", arr);
}
1.8.3. 括号匹配的测试函数
void BracketMatching_Test() {
    int i = 0;
    char arr[1000] = "";    //初始化数组'\000'
    char arr_1[1000] = "";
    Terminal_iInput(arr);
    Match(arr);
    File_Input(arr_1);
    printf("%s\n", arr_1);
    Match(arr_1);
}

2. 循环队列

2.1 循环队列的结构定义
typedef int QElemType;
#define MaxSize 500
typedef struct {
    QElemType data[MaxSize];
    int front;
    int rear;
} SeqQueue;
2.2 实现循环队列的初始化
void InitQueue(SeqQueue *Q) {
    Q->front = Q->rear = 0;
    for (int i = 0; i < MaxSize; ++i) {
        Q->data[i] = 0;
    }
}
2.3 循环队列的判满
bool Is_Full_Q(SeqQueue Q) {
    if ((Q.rear) % MaxSize == Q.front)
        return true;
    else
        return false;
}
2.4 循环队列的判空
bool Is_Empty_Q(SeqQueue Q) {
    if (Q.front == Q.rear)
        return true;
    else
        return false;
}
2.5 循环队列的入队
bool Push_Q(SeqQueue *Q, QElemType e) {
    if ((Q->rear + 1) % MaxSize == Q->front) //队列满了
        return false;
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MaxSize;
    return true;
}
2.6 循环队列的出队
bool Pop_Q(SeqQueue *Q, QElemType *e) {
    if (Q->front == Q->rear)
        return false;
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MaxSize;
    return true;
}
2.7 循环队列的读取队头元素
bool GetHead(SeqQueue Q, QElemType *e) {
    if (Q.front == Q.rear)
        return false;
    *e = Q.data[Q.front];
    return true;
}
2.8 循环队列的读取队尾元素
bool GetRear(SeqQueue Q, QElemType *e) {
    if (Q.front == Q.rear)
        return false;
    *e = Q.data[Q.rear];
    return true;
}
2.9 queue.h 文件
//
// Created by Louie on 2022/10/7.
//
typedef int QElemType;
#define MaxSize 500
typedef struct {
    QElemType data[MaxSize];
    int front;
    int rear;
} SeqQueue;

void InitQueue(SeqQueue *Q) {
    Q->front = Q->rear = 0;
    for (int i = 0; i < MaxSize; ++i) {
        Q->data[i] = 0;
    }
}

bool Is_Empty_Q(SeqQueue Q) {
    if (Q.front == Q.rear)
        return true;
    else
        return false;
}

bool Is_Full_Q(SeqQueue Q) {
    if ((Q.rear) % MaxSize == Q.front)
        return true;
    else
        return false;
}

bool Push_Q(SeqQueue *Q, QElemType e) {
    if ((Q->rear + 1) % MaxSize == Q->front) //队列满了
        return false;
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MaxSize;
    return true;
}

bool Pop_Q(SeqQueue *Q, QElemType *e) {
    if (Q->front == Q->rear)
        return false;
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MaxSize;
    return true;
}

bool GetHead(SeqQueue Q, QElemType *e) {
    if (Q.front == Q.rear)
        return false;
    *e = Q.data[Q.front];
    return true;
}

bool GetRear(SeqQueue Q, QElemType *e) {
    if (Q.front == Q.rear)
        return false;
    *e = Q.data[Q.rear];
    return true;
}


#ifndef DATASTRUCT_QUEUE_H
#define DATASTRUCT_QUEUE_H

#endif //DATASTRUCT_QUEUE_H
2.10 基于循环队列实现杨辉三角形N行数据的输出

太简单了，我就不说了，亲们自己看，看不懂的评论留言，或者联系扣扣 1633497269

void YangHuiTriangle() {
    SeqQueue Q;
    QElemType x;
    InitQueue(&Q);
    Push_Q(&Q, 1);
    QElemType t;
    printf("请输入行数：");
    int num;
    scanf("%d", &num);
    for (int i = 2; i <= num + 1; i++) {

        for (int j = 0; j <= num - i; ++j) {
            printf("   ");
        }
        Push_Q(&Q, 1);
        for (int j = 1; j <= i - 2; j++) {
            Pop_Q(&Q, &t);
            printf("%d    ", t);

            GetHead(Q, &x);
            t = t + x;

            Push_Q(&Q, t);
        }
        Pop_Q(&Q, &x);
        printf("%d\n", x);
        Push_Q(&Q, 1);
    }

}

3. 完整代码

#include <cstdio>
#include "stack.h"
#include "queue.h"

void Match(const char arr[]) {  //括号匹配，arr[]存放所有的括号
    SqStack sqStack;
    InitStack(&sqStack);    //初始化栈
    int i = 0;  //数组arr[]下标
    SElemType e;    //存放栈顶元素
    while (arr[i] != '\000') {   //遍历arr[]数组
        if (arr[i] == '(' || arr[i] == '{' || arr[i] == '[') {
            Push(&sqStack, arr[i]);     //如果是左括号就进栈
        } else if (arr[i] == ')' || arr[i] == '}' || arr[i] == ']') {     //如果匹配到右括号就与栈顶元素进行比较
            switch (arr[i]) {
                case ')':
                    e = GetTop(sqStack);
                    if (e == '(')
                        Pop(&sqStack, &e);      //如果当前的括号与栈顶符号匹配，那么就将栈顶元素压出栈
                    break;
                case ']':
                    e = GetTop(sqStack);
                    if (e == '[')
                        Pop(&sqStack, &e);
                    break;
                case '}':
                    e = GetTop(sqStack);
                    if (e == '{')
                        Pop(&sqStack, &e);
                    break;
            }
        }
        i++;
    }
    if (IsEmpty(sqStack))    //如果栈为空，说明匹配成功
        printf("Bracket matching succeeded!!!\n");
    else
        printf("Bracket matching failed!!!\n");
}

/*
 * 该函数的作用是读取文件，然后筛选出括号并存入arr[]数组中
 */
void File_Input(char arr[]) {
    int ch = 0;
    int count = 0;
    FILE *fp;
    fp = fopen("F:\\DataStruct\\homework\\NO3.cpp ", "r");//test文件的绝对路径
    if (fp == nullptr)
        printf("file is error\n");
    while (ch != EOF) {
        ch = fgetc(fp);
        if (ch == '(' || ch == ')' || ch == '{' || ch == '}' || ch == '[' || ch == ']')
            arr[count++] = ch;

    }
    fclose(fp);
}


void Terminal_iInput(char arr[]) {
    printf("Please enter bracket sequence:\n");
    scanf("%s", arr);
}

void BracketMatching_Test() {
    int i = 0;
    char arr[1000] = "";    //初始化数组'\000'
    char arr_1[1000] = "";
    Terminal_iInput(arr);
    Match(arr);
    File_Input(arr_1);
    printf("%s\n", arr_1);
    Match(arr_1);
}

void YangHuiTriangle() {
    SeqQueue Q;
    QElemType x;
    InitQueue(&Q);
    Push_Q(&Q, 1);
    QElemType t;
    printf("请输入行数：");
    int num;
    scanf("%d", &num);
    for (int i = 2; i <= num + 1; i++) {

        for (int j = 0; j <= num - i; ++j) {
            printf("   ");
        }
        Push_Q(&Q, 1);
        for (int j = 1; j <= i - 2; j++) {
            Pop_Q(&Q, &t);
            printf("%d    ", t);

            GetHead(Q, &x);
            t = t + x;

            Push_Q(&Q, t);
        }
        Pop_Q(&Q, &x);
        printf("%d\n", x);
        Push_Q(&Q, 1);
    }

}

int main() {
    BracketMatching_Test();
    YangHuiTriangle();


    return 0;

}
芝士372
关注
专栏目录
顺序栈 链栈 顺序队列 链式队列 循环队列的常用算法.zip
08-16
本资料包"顺序栈 链栈 顺序队列 链式队列 循环队列的常用算法.zip"涵盖了这四种数据结构的基本操作，包括入队、出队、入栈、出栈等核心算法。 1. **顺序栈**： - 顺序栈是一种基于数组实现的栈，其元素存储在连续...
顺序栈实现创建，判空，判满，进栈，出栈，遍历，销毁
m0_71934534的博客
11-01 307
顺序栈实现创建，判空，判满，进栈，出栈，遍历，销毁
数据结构——队列（queue）
热门推荐
盛夏光年
08-02 2万+
队列（queue） 队列（queue）：只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出（First In First Out）的线性表，简称FIFO。 允许插入的一端称为队尾，允许删除的一端称为队头 1、抽象数据类型 ADT 队列(Queue) Data 同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。 Opera
超清晰-数据结构之队列
MClink的博客
12-16 1237
前言：毕业后忙于工作，较少花时间在基础上，突然想起某位大佬的名言，当你不知道该学什么的时候，就去看看基础，是的，技术的范畴确实太大了，我们很容易就会迷茫，不管是哪门语言的开发者，不管你学的是什么武功，内功精髓本质上还是一样的，大学以来，我一直对递归和栈的使用处于一种半知半觉的状态，何为半知半觉，就是我能说出它的概念以及简单的应用，但是问细下去，便没办法了，这篇文章我想先来说说我对队列的理解,下一...
数据结构_栈与队列
fazstyle的博客
04-25 2040
1、栈的定义 (1)栈的定义 栈(stack)是限定仅在表尾进行插入和删除操作的线性表。 把允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，即表尾，不含任何数据元素的栈称为空栈。栈又称为后进先出(Last In First Out)的线性表，简称为LIFO结构。 栈中的元素具有先驱后继的关系。 栈的插入操作叫作进栈，也称为压栈、入栈；栈的删除操作叫作出栈，也称为弹栈。如下图...
数据结构基础07（顺序栈和顺序循环队列）
麦克斯韦小迷妹儿~的博客
04-11 1439
顺序栈和顺序循环队列一、顺序栈0.头文件1. 判空2. 申请新空间3. 初始化4.判断栈是否为空5.入栈6.取栈顶7.出栈8.清除函数9.销毁函数10.主函数二、顺序循环队列0.头文件1. 判空2. 判断队列是否为空3. 初始化4.判断队列是否为满5.入队6.获取队头7.出队8.清除队列（不释放空间）9.销毁队列（将内存空间销毁）10.主函数 一、顺序栈 0.头文件 #pragma once #d...
实现顺序栈或循环队列的存储
05-09
在循环队列中，`front`和`rear`可以超出数组的实际边界，但通过模运算 `%MAXQSIZE` 可以使它们保持在数组范围内。 2. **返回循环队列的长度** 循环队列的长度可以通过计算`rear`和`front`之间的元素个数得到。由于...
数据结构实验报告2-栈与队列-队列基本操作算法-实验内容及要求.docx
07-06
通过本实验，学生能够深入理解循环队列的概念，并熟练掌握其实现方法。 #### 实验要求与内容 1. **实验内容**：要求编写一个程序来建立容量为 _n_ 的循环队列（推荐 _n_ = 8），并实现以下功能： - 输入字符 `#` ...
数据结构栈和队列
01-02
总结来说，这个实验旨在通过实际编程加深对栈和队列这两种数据结构的理解，掌握它们的逻辑结构、存储结构和基本运算，同时锻炼了实际编程能力和问题解决能力。通过这样的实践，学生可以更好地运用这些数据结构解决...
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
【数据结构】栈与队列的基本操作及其应用
weixin_72437555的博客
11-20 1584
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。​笔者本周粗略学习了栈与队列的知识及其应用，特此总结记录自己的经验。(学完之后cpu烧了/(ㄒoㄒ)/~~)提示：以下是本篇文章正文内容，下面案例可供参考栈(Stack):一种可以实现“先进后出”的存储结构。可以将其想象为箱子，先放进箱子的东西后拿出来。
数据结构——栈与队列（特详解），不会我亲自教你！！！
weixin_52439435的博客
04-15 2859
启示： 栈与队列 栈是限定仅在表位进行插入和删除操作的线性表 队列是只允许在一段进行插入操作，而在另一端进行删除操作的线性表 一、栈的定义 在我们软件应用中，栈这种先进先出的数据结构的应用是非常普遍的。比如你用手机浏览器上网时，不管什么浏览器都有一个“后退”键，你点击后可以按访问顺序的逆序加载浏览过的网页，比如你本来看着新闻好好的，突然看到一个链接说，有一个可以让你年薪100万的工作，你毫不犹豫点击它，跳转进去一看，这是啥呀，具体内容我也就不说了，骗人骗得一点水平都没有。此时你还想回去继续看新闻，就可以.
数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题
最新发布
Crocodile1006的博客
10-15 2602
栈和队列上机实验、要求、栈的实现（以顺序栈为例）、队列的实现（以顺序队列为例）、利用栈实现进制转换、利用队列解决约瑟夫环问题、全部源码、Stack.h、Queue.h、test.cpp
【栈和队列经典题目】用队列实现栈，用栈实现队列，设计循环队列
weixin_74113106的博客
05-18 159
用队列实现栈，用栈实现队列，设计循环队列
【C++】栈和队列
cout0
12-01 736
顺序栈 #include <iostream> #include <stdlib.h> using namespace std; #define MAXSIZE 100 //顺序栈初始化时分配的存储空间长度 typedef struct{ char *base; //栈底指针,栈中元素为字符 char *top; //栈顶指针 int stacksi...
C语言顺序栈的实现以及进制转换
m0_51415606的博客
10-31 8005
栈是 仅限定在表尾插入或输出的一种链表形式，它不能像链表一样随便输出、随便插入，是一种“先进后出”的形式，可以理解为逆序输出。 1.写顺序栈，我们需要先在头文件部分定义一个存储空间初始分配量和一个存储空间分配增量 #include<stdio.h> #include<stdlib.h> #define MAX 100//第一次分配内存空间时分配100 #define ADD 10//当我们输入的数据大于初始空间时就增加内存空间，每次增加10 2.然后是定义结构体变量，定义三个，栈
数据结构基础系列(3)：栈和队列
09-08
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第3部分栈和队列，介绍在系统软件和应用软件开发中大有用途的两种特殊线性表——栈和队列的构组成、存储结构的选择，以及基本运算的实现，通过相关的应用案例介绍了这些数据结构的应用方法。
数据结构实验报告3————栈和队列及其应用
weixin_56665183的博客
10-28 1万+
实验内容 （1）栈的定义、基本操作的实现，以及典型应用 ①编程实现顺序栈/链栈的基本操作（如：栈的初始化、判断栈空、求栈的长度、取栈顶、入栈、出栈等），并设计菜单调用。（必做） ②利用栈结构，实现将任意的十进制整数N转成r（2≤r≤16）进制并输出。（选做） ③利用栈结构，对键盘输入任意字符串，判断其中的括号是否匹配。（选做） ④编写算法对键盘输入的整数序列a1a2…an进行如下操作：当ai≠-1时，将ai进栈；当ai=-1时，输出栈顶整数并出栈(1≤i≤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值