C++栈和队列应用实验

最新推荐文章于 2024-06-08 18:30:35 发布
最新推荐文章于 2024-06-08 18:30:35 发布
阅读量1.3k 收藏 9
点赞数
分类专栏： C++数据结构 文章标签： c++ 算法 数据结构 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51495235/article/details/127947317
版权

1. 假设正读和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’则不是回文。试写一个算法判别读入的一个以’@’为结束符的字符序列是否是“回文”。（利用栈和队列两种结构实现）。

运行结果如图所示：
在这里插入图片描述在这里插入图片描述
完整代码

#include <iostream>
#include <string>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define null 0;
#define n 10;

using std::cout;
using std::cin;
using std::endl;
using std::string;
using namespace std;



struct stack {
    char *base;
    char *top;
    int stacksize;
};

void initstack(struct stack *s) {
    s->base = (char *) malloc(20 * sizeof(char));
    if (!s->base) exit(0);
    s->top = s->base;
    s->stacksize = 20;
    return;
}

void push(struct stack *s, char e) {
    if (s->top - s->base >= s->stacksize) {
        s->base = (char *) realloc(s->base, (s->stacksize + 10) * sizeof(char));
        if (!s->base) exit(0);
        s->top = s->base + s->stacksize;
        s->stacksize += n;
    }
    *(s->top)++ = e;
    return;
}

char pop(struct stack *s) {
    char e;
    if (s->top == s->base) return null;
    e = *--s->top;
    return e;
}

void clearstack(struct stack *s) {

    if (s->top == s->base) return;
    s->top = s->base;
    return;
}

int StackEmpty(struct stack *s) {

    if (s->top == s->base) return 1;
    else return 0;

}

typedef int elemType;

/* 以下是关于队列链接存储操作的6种算法  */

struct sNode {
    elemType data;            /* 值域 */
    struct sNode *next;        /* 链接指针 */
};

struct queueLK {
    struct sNode *front;    /* 队首指针 */
    struct sNode *rear;        /* 队尾指针 */
};


/* 1.初始化链队 */
void initQueue(struct queueLK *hq) {
    hq->front = (sNode *) malloc(20 * sizeof(struct sNode));
    if (!hq->front) exit(0);
    hq->front = hq->rear = NULL;        /* 把队首和队尾指针置空 */
    return;
}


/* 2.向链队中插入一个元素x */
void enQueue(struct queueLK *hq, elemType x) {
    /* 得到一个由newP指针所指向的新结点 */
    struct sNode *newP;
    newP = (sNode *) malloc(sizeof(struct sNode));
    if (newP == NULL) {
        printf("内存空间分配失败！ ");
        exit(1);
    }
    /* 把x的值赋给新结点的值域，把新结点的指针域置空 */
    newP->data = x;
    newP->next = NULL;
    /* 若链队为空，则新结点即是队首结点又是队尾结点 */
    if (hq->rear == NULL) {
        hq->front = hq->rear = newP;
    } else {                      /* 若链队非空，则依次修改队尾结点的指针域和队尾指针，使之指向新的队尾结点 */
        hq->rear->next = newP;
        hq->rear = newP;/* 注意赋值顺序哦 */
    }
    return;
}


/* 3.从队列中删除一个元素 */
int outQueue(struct queueLK *hq) {
    struct sNode *p;
    int temp;
    /* 若链队为空则停止运行 */
    if (hq->front == NULL) {
        printf("队列为空，无法删除！ ");
        exit(1);
    }
    temp = hq->front->data;        /* 暂存队尾元素以便返回 */
    p = hq->front;                /* 暂存队尾指针以便回收队尾结点 */
    hq->front = p->next;        /* 使队首指针指向下一个结点 */
    /* 若删除后链队为空，则需同时使队尾指针为空 */
    if (hq->front == NULL) {
        hq->rear = NULL;
    }
    free(p);        /* 回收原队首结点 */
    return temp;    /* 返回被删除的队首元素值 */
}


/* 4.检查链队是否为空，若为空则返回1, 否则返回0 */
int emptyQueue(struct queueLK *hq) {
    /* 判断队首或队尾任一个指针是否为空即可 */
    if (hq->front == NULL) {
        return 1;
    } else {
        return 0;
    }
}


/************************************************************************/

void useStack(struct stack s, char *a) {
    cout << "输入一串字符以@结尾" << endl;
    cin >> a;
    for (int i = 0; i < strlen(a) - 1; i++) {
        if (a[i] != '\@') {
            push(&s, a[i]);
        }
    }
    int i = 0;
    while (!StackEmpty(&s)) {
        if (pop(&s) != a[i]) {
            cout << "不是回文数" << endl;
            break;
        }
        i++;
    }
    if (StackEmpty(&s)) {
        cout << "是回文数" << endl;
    }
}

void useStackAnDQueue(struct queueLK q, struct stack s, char *a) {
    cout << "输入一串字符以@结尾" << endl;
    cin >> a;
    for (int i = 0; i < strlen(a) - 1; i++) {
        if (a[i] != '\@') {
            push(&s, a[i]);
            enQueue(&q, a[i]);
        }
    }
    while (!StackEmpty(&s) && !emptyQueue(&q)) {
        if (pop(&s) != outQueue(&q)) {
            cout << "不是回文数" << endl;
            break;
        }
    }
    if (StackEmpty(&s) && emptyQueue(&q)) {
        cout << "是回文数" << endl;
    }
}

int main() {
    struct queueLK q;
    struct stack s;
    char a[10];
    initQueue(&q);
    initstack(&s);

    useStackAnDQueue(q, s, a);

    //利用栈和队列的操作特点写一段代码

    //判别读入的一个以’@’为结束符的字符序列是否是“回文”。
}

运行截图
在这里插入图片描述
在这里插入图片描述

2. 利用栈的存储结构完成括号匹配程序。

运行结果如图所示：
在这里插入图片描述
在这里插入图片描述
完整代码

/***链栈实现括号匹配***/

#include<iostream>

using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef char SElemType;
typedef int Status;
typedef struct SNode {
    int data;
    struct SNode *next;
} SNode, *LinkStack;

Status InitStack(LinkStack &S) {
    S = NULL;
    return OK;
}

bool StackEmpty(LinkStack S) {
    if (!S)
        return true;
    return false;
}

Status Push(LinkStack &S, SElemType e) {
    SNode *p = new SNode;
    if (!p) {
        return OVERFLOW;
    }
    p->data = e;
    p->next = S;
    S = p;
    return OK;
}

Status Pop(LinkStack &S, SElemType &e) {
    SNode *p;
    if (!S)
        return ERROR;
    e = S->data;
    p = S;
    S = S->next;
    delete p;
    return OK;
}

Status GetTop(LinkStack &S) {
    if (!S)
        return ERROR;
    return S->data;
}

//算法3.21　括号的匹配
Status Matching() {//检验表达式中所含括号是否正确匹配，如果匹配，则返回true，否则返回false
    //表达式以“#”结束
    char ch;
    SElemType x;
    LinkStack S;
    InitStack(S);
    cin >> ch;
    int flag = 1;
    while (ch != '#' && flag) {
        switch (ch) {
            case '[':
            case '(':
                Push(S, ch);
                break;
            case ')':
                if (!StackEmpty(S) && GetTop(S) == '(') {
                    Pop(S, x);
                } else {
                    flag = 0;
                }
                break;
            case ']':
                if (!StackEmpty(S) && GetTop(S) == '[') {
                    Pop(S, x);
                } else {
                    flag = 0;
                }
                break;
        }
        cin >> ch;
    }
    if (StackEmpty(S) && flag) {
        return true;
    } else {
        return false;
    }
}

int main() {
    LinkStack S;
    cout << "请输入待匹配的表达式，以“#”结束：" << endl;
    int flag = (int) Matching();
    if (flag)
        cout << "括号匹配成功！" << endl;
    else
        cout << "括号匹配失败！" << endl;
    return 0;
}

运行截图
在这里插入图片描述
在这里插入图片描述

3. （选做）利用栈的存储结构完成行编辑程序，要求如下：

输入一行字符串，用户在输入错误时可以用#和@进行修正，其中#为退格符，@为退行符。要求输出修正后的字符串。如字符串“hw@whli##ilr#e”修正后输出为“while”。
运行结果如图所示：
在这里插入图片描述
完整代码

#include"stdio.h"
#include"stdlib.h"
#include"string.h"

#include <iostream>
#include<assert.h>
#include<malloc.h>
#include<string.h>
#include<stdio.h>
#include<cstring>

using namespace std;
#define null 0
#define n 10
struct stack {
    char *base;
    char *top;
    int stacksize;
};

void initstack(struct stack *s) {
    s->base = (char *) malloc(20 * sizeof(char));
    if (!s->base) exit(0);
    s->top = s->base;
    s->stacksize = 20;
    return;
}

void push(struct stack *s, char e) {
    if (s->top - s->base >= s->stacksize) {
        s->base = (char *) realloc(s->base, (s->stacksize + n) * sizeof(char));
        if (!s->base) exit(0);
        s->top = s->base + s->stacksize;
        s->stacksize += n;
    }
    *(s->top)++ = e;
    return;
}

char pop(struct stack *s) {
    char e;
    //if(s->top==s->base)    return 0;
    e = *(--s->top);
    return e;
}

void clearstack(struct stack *s) {

    if (s->top == s->base) return;
    s->top = s->base;
    return;
}

int main() {
    //输入一行字符串，用户在输入错误时可以用#和@进行修正，
    //其中#为退格符，@为退行符。要求输出修正后的字符串。
    char ch;
    struct stack s;
    struct stack t;
    initstack(&s);
    initstack(&t);
    cout << "输入字符串,以!结束" << endl;
    ch = getchar();
    while (ch != '!') {
        switch (ch) {
            case '#':
                // 出栈
                pop(&s);
                break;
            case '@':
                clearstack(&s);
                break;
            default:
                push(&s, ch);
        }
        ch = getchar();
    }
    // hw@whli##ilr#e!
    cout << s.base;
}

运行截图
在这里插入图片描述

康小庄
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构之栈和队列---回文判断
逆天的博客
08-03 9166
问题：假设称正读和反读都相同的字符序列为回文，例如，‘abba’和‘abcba'是回文，‘abcde’和‘ababab'则不是回文。试写一个算法判别读入的一个一‘@’为结束符的字符序列是否是回文。 算法思想：栈的操作为后进先出，队列的操作为先进先出，利用栈和队列的这两个性质，比较出栈和出队的元素是否相同，即可判断字符序列是否为回文 栈的基本操作 队列的基本操作 //回文的判别算法
c语言用栈判断回文实验报告,数据结构C语言回文判断(运用栈以及列完成).doc
weixin_42136826的博客
05-20 975
数据结构实验报告回文判断班 级：学号：学生姓名：指导教师：时间：2015年5月5日1．实验目的：熟悉栈和队列的各项操作，区别栈和队列的操作原理。2．实验内容：利用栈的操作完成读入的一个以@结尾的字符序列是否是回文序列的判断.回文序列即正读与反读都一样的字符序列;例如:123&321@是;123&4321@、123&312@不是算法思想：从键盘上读取一个字符，同时存储在...
常用C++队列（Queue）详解与应用
w_m_x_d的博客
06-08 1190
常用C++队列(queue)详解
队列2
chengfangang的专栏
05-21 927
#include stdio.h> #include stdlib.h> typedef int elemType; /************************************************************************/ /*                    以下是关于队列链接存储操作的6种算法               */ /
数据结构实验报告（四）——栈和字符串
future_dreaming的博客
01-10 1480
通过本次实验，我们学会了栈的结构及基本运算的实现方法、用栈实现表达式计算的基本技术，掌握了应用栈进行问题求解的基本方法，理解了串的有关概念和运算实现，掌握了快速模式匹配等串的典型算法，这次的实验涉及到的知识点有点多，最开始有点难理解，但是通过不断的练习，最终还是能够准确地理解这些算法。创建字符串、再实现字符串的系列操作，注意字符串的长度。先建立一个空队列，进行判空、入队、出队、打印等操作。1、掌握栈的结构及基本运算的实现方法。2、掌握用栈实现表达式计算的基本技术。3、掌握应用栈进行问题求解的基本方法。
数据结构与算法3.31
qq_62689346的博客
10-22 1147
假设称正读和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’和‘ababab’则不是回文。试写一个算法判别读入的一个以‘@’为结束符的字符序列是否是“回文”。 输入一个以@结尾的字符序列，判断该字符序列是否为回文输出：abba是回文或abcba不是回文； 输入：abcba@ 输出：abcba是回文
第四次实验——栈和队列（二）
pixiness717的博客
10-25 977
假设称正读和反读都相同的字符序列为“回文”。例如，“abba”和“abcba”是回文，“abcde”和"ababab"不是回文。试写利用栈和队列来实现的一个算法判别读入一个以“@”为结束符的字符序列是否是"回文"。
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
C++ 栈和队列 中缀表达式求值
04-24
采用栈和队列数据结构及C++程序设计语言实现中缀表达式求值#数据结构实验#栈和队列应用#C++程序设计语言
数据结构实验栈和队列详细实验报告
04-15
2. **链式存储结构**：链式存储结构使用链表来实现栈和队列，每个元素包含数据域和指针域，指针域指向下一个元素。这样，插入和删除操作只需要改变几个指针，而不需要移动元素。链式结构提供了更大的灵活性，但元素...
基于 C++线性表及其实现 栈和队列及其应用课程实验（实验报告+源码）
最新发布
06-27
【作品名称】：线性表及其实现 栈和队列及其应用【课程实验】（实验报告+源码） 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 ...
回文判断,回文判断,试编写一个算法,判断依次读入的一个以@为结素符的字母序列
11-24
回文判断,试编写一个算法,判断依次读入的一个以@为结素符的字母序列。自己找到的，希望帮到你们。
回文(栈和队列)
年轻过成了秃顶
01-04 3490
题目描述 假设称正读和反读都相同的字符序列为“回文”，例如，‘abba‘ 和 ‘abcba‘是回文，‘abcde‘ 和 ‘ababab‘ 则不是回文。试写一个算法判别字符序列是否是“回文”。 输入 abcba 输出 是回文 样例输入 Copy ababab 样例输出 Copy 不是回文 分析： 本题的话，我们可以利用栈。栈弹出，然后还有一个数组从左往右遍历。判断是否相等。 #include"st...
数据结构算法题：回文数的实现
Scavenger的博客
09-27 1605
数据结构：回文数的算法实现。
数据结构——用栈解决回文字符问题
qq_50675813的博客
11-23 2952
回文 回文是指正读反读均相同的字符序列,如“abba”和“abdba”均是回文，但“good”不是回文。试写一个算法判定给定的字符序列是否为回文。（提示：将一半字符入栈。） 所需的知识前提：栈 以下是顺序栈的基本算法 结构表示，初始化，销毁栈，入栈，出栈，得到栈顶元素，判断栈是否为空等算法。 #include<stdio.h> #include<bits/stdc++.h> using namespace std; #include<malloc.h> #include&
判定给定的字符序列是否为回文【数据结构】【栈】
weixin_69200869的博客
10-14 3625
回文是指正读反读均相同的字符序列，如“abba”和“abdba”均是回文，但“good”不是回文。写一个算法判定给定的字符序列是否为回文。（提示：将一半字符入栈）。
用数据结构的栈和队列 写 回文判断
zdg05183的专栏
05-18 7102
假设称正读和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’和‘ababab’则不是回文。试写一个算法判别读入的一个以‘@’为结束符的字符序列是否是“回文”。编程实现该程序。 #include #include typedef struct node{ char data; struct node *next;}node;typedef stru
半字符入栈的回文判定
weixin_57940917的博客
10-27 1621
回文是指正读反读均相同的字符序列；如“abba”和“abdba”均是回文，但“good”不是回文。试写一个算法判定给定的字符序列是否是回文。（提示：将一半字符入栈） 算法分析：回文的判定关键在于字符串是否是关于中心元素对称的，即将字符串逆序在与原字符串进行比较。由于栈具有先进后出的特点，所以栈是该问题的最佳解决方法，将字符串入栈，然后再进行弹出操作，与原字符串进行比较，相同即为回文。 考虑到待测字符串会有长短的不同，短字符串用上述方法即可，但长字符串会造成时间的...
栈和队列的基本操作实现【实验】
总而言之，在本次数据结构实验中，我们通过实现栈和队列的基本操作，学习了栈和队列的逻辑结构和存储结构，并掌握了栈和队列的相关基本运算。这些知识和技能对于我们进一步学习和应用数据结构具有重要意义。希望在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值