顺序栈链栈基本操作及应用-数据结构类C语言

编程语言 2023-05-17 06:09:57 阅读次数: 0

目录

一、功能函数定义文件(func.cpp)

二、主函数调用文件(main.cpp)

三、头文件声明文件(before.h)

四、运行环境

一、功能函数定义文件(func.cpp)

#include <iostream>
#include <cstdlib>
#include "before.h"

using namespace std;

//顺序栈的相关功能函数定义
status InitStack(SqStack &S,int maxsize)
{
    S.base = (ElemType *)malloc(sizeof(ElemType)*maxsize);
    if(!S.base) return ERR;      //创建失败 空间不足

    S.top = S.base;              //空栈
    S.numb = maxsize;            //栈的最大容量
    return OK;
}//建栈

void PrintStack_SqStack(SqStack S)
{
    int cnt = 0;
    cout << "--当前顺序栈为：" << endl;
    cout << "--栈底=>";
    while(*S.base && S.top!=S.base)
    {
        cnt ++;
        cout << *(S.base++) << "  ";
        if(cnt%7 == 0) cout << endl << "-------";
    }
    cout << endl;
}//打印顺序栈

status Push_SqStack(SqStack &S,ElemType e)
{
    if(S.top-S.base >= S.numb) return OVERFLOW;  //栈满

    *S.top = e;
    S.top ++;
    return OK;
}//入栈

status Pop_SqStack(SqStack &S,ElemType &e)
{
    if(S.top == S.base) return ERR;  //空栈

    e = *(--S.top);
    return OK;
}//出栈

status GetTop_SqStack(SqStack S)
{
    if(S.top == S.base) return ERR; //空栈

    return *(S.top-1);
}//取栈顶元素

void DestroySqStack(SqStack &S)
{
    if(S.base)
    {
        free(S.base);
        S.numb = 0;
        S.base = S.top = NULL;
    }
}//销毁顺序栈

void ClearSqStack(SqStack &S)
{
    if(S.base) S.top = S.base;
}//清空顺序栈

status StackEmpty_SqStack(SqStack S)
{
    if(S.top == S.base) return OK;
    else return ERR;
}//判断顺序栈是否为空

status StackLength_SqStack(SqStack S)
{
    return (S.top-S.base);
}//顺序栈的长度

void Conversion_SqStack(SqStack &M,int con,int maxsize)
{
    InitStack(M,maxsize);
    int num;
    cout << "请输入需要转换的原始十进制数值：";
    cin >> num;
    int number = num;
    do
    {
        Push_SqStack(M,num%con);
        num /= con;
    }while(num != 0);
    cout << "10进制数" << number << "转换为" << con << "进制数为：";
    do
    {
        int e;
        Pop_SqStack(M,e);
        if(e < 10) cout << e;
        else if(e >= 10)
        {
            char ch = 'A' + e - 10;
            cout << ch;
        }
    }while(StackEmpty_SqStack(M) == ERR);
    cout << endl;
}//将顺序栈中的元素进行进制转换

status Compare_SqStack()
{
    SqStack C;
    int maxsize;                      //最多存储的括号数量
    int prime = OK,judge_1 = OK,judge_2 = OK;//记录括号是否匹配、满栈判断、空栈判断
    char ch;                          //存储每次输入的单个字符
    ElemType e;                       //存储输入的单个字符的对应ASCII码
    cout << "请输入需要查看括号匹配的字符串中的括号最多数量(实际入栈为其一半)：";
    cin >> maxsize;
    InitStack(C,maxsize);
    cout << "请输入你需要查看括号是否匹配的字符串(以‘#’结束)：" << endl;
    while((ch = getchar()) != '#' && prime == OK && judge_1 == OK)
    {
        switch(ch)
        {
            case '(':
            case '[':
            case '{':
                e = ch-'0';
                judge_1 = Push_SqStack(C,e);       //满栈
                break;
            case ')':
                judge_2 = Pop_SqStack(C,e);    //空栈
                if(judge_2 == ERR || e != '('-'0') prime = ERR;
                break;
            case ']':
                judge_2 = Pop_SqStack(C,e);    //空栈
                if(judge_2 == ERR || e != '['-'0') prime = ERR;
                break;
            case '}':
                judge_2 = Pop_SqStack(C,e);    //空栈
                if(judge_2 == ERR || e != '{'-'0') prime = ERR;
                break;
            default:
                break;
        }
    }
    if(prime == OK && ch =='#' && StackEmpty_SqStack(C) == OK && judge_1 == OK) return OK;
    else if(judge_1 == OVERFLOW) return OVERFLOW;
    else return ERR;
}//顺序栈的括号匹配判断

//链栈相关功能函数定义
void InitStack_LinkStack(LinkStack &S)
{
    S = NULL;
}//初始化链栈

void PrintLinkStack(LinkStack S)
{
    StackNode *p = S;
    int numb = 0;
    cout << "当前链栈为：" << endl;
    cout << "栈顶=>";
    while(p)
    {
        cout << p->data << "  ";
        numb ++;
        p = p->next;
        if(numb%7 == 0) cout << endl << "-------";
    }
    cout << endl;
}//输出链栈

void Push_LinkStack(LinkStack &S,ElemType e)
{
    StackNode *s = (StackNode *)malloc(sizeof(StackNode));
    s->data = e;
    s->next = S;
    S = s;
}//入栈

void Pop_LinkStack(LinkStack &S,ElemType &e)
{
    StackNode *p;
    p = S;
    e = S->data;
    S = S->next;
    free(p);
}//出栈

status GetTop_LinkStack(LinkStack S)
{
    if(S == nullptr) return ERR;      //空栈无栈顶元素
    return S->data;
}//取栈顶元素

void DestroyLinkStack(LinkStack &S)
{
    StackNode *p = S;
    while(p)
    {
        S = S->next;
        free(p);
        p = S;
    }
}//销毁链栈

void ClearLinkStack(LinkStack &S)
{
    StackNode *p = S->next;
    while(p)
    {
        S->next = p->next;
        free(p);
        p = S->next;
    }
}//清空链栈

status StackEmpty_LinkStack(LinkStack S)
{
    if(S->next == NULL) return OK;
    else return ERR;
}//判断链栈是否为空

status StackLength_LinkStack(int &num)
{
    return num;
}//返回链栈的长度

void Conversion_LinkStack(LinkStack &M,int con)
{
    InitStack_LinkStack(M);
    int num;
    cout << "请输入需要转换的原始十进制数值：";
    cin >> num;
    int number = num;
    do
    {
        Push_LinkStack(M,num%con);
        num /= con;
    }while(num != 0);
    cout << "10进制数" << number << "转换为" << con << "进制数为：";
    int e;
    while(M != NULL)
    {
        e = -1;
        Pop_LinkStack(M,e);
        if(e < 10) cout << e;
        else if(e >= 10)
        {
            char ch = 'A' + e -10;
            cout << ch;
        }
    }
    cout << endl;
}//链栈转换进制

status Compare_LinkStack()
{
    LinkStack C;
    InitStack_LinkStack(C);
    char ch;
    ElemType e;
    int prime = OK,judge_2 = OK;
    cout << "请输入需要查看括号是否匹配的字符串(以‘#’结束)：" << endl;
    while((ch=getchar()) != '#' && prime == OK)
    {
        switch (ch)
        {
            case '(':
            case '[':
            case '{':
                e = ch-'0';
                Push_LinkStack(C,e);
                break;
            case ')':
                judge_2 = StackEmpty_LinkStack(C);
                Pop_LinkStack(C,e);
                if(e != '('-'0' || judge_2 == ERR) prime = ERR;
                break;
            case ']':
                judge_2 = StackEmpty_LinkStack(C);
                Pop_LinkStack(C,e);
                if(e != '['-'0' || judge_2 == ERR) prime = ERR;
                break;
            case '}':
                judge_2 = StackEmpty_LinkStack(C);
                Pop_LinkStack(C,e);
                if(e != '{'-'0' || judge_2 == ERR) prime = ERR;
                break;
            default:
                break;
        }
    }
    if(ch == '#' && prime == OK && C == NULL) return OK;
    else return ERR;
}//链栈来进行字符串括号匹配的判断

//菜单打印
void Menu()
{
    printf("\t\t\t*****************以下为程序菜单******************************\n");
    printf("\t\t\t\t1、顺序栈                      2、链栈                     \n");
    printf("\t\t\t\t0、退出程序                                                \n");
    printf("\t\t\t************************************************************\n");
}

void Menu_SqStack()
{
    printf("\t\t\t*****************以下为顺序栈的菜单**************************\n");
    printf("\t\t\t\t1、建栈                         2、入栈                    \n");
    printf("\t\t\t\t3、出栈                         4、打印顺序栈               \n");
    printf("\t\t\t\t5、取栈顶元素                    6、进制转换                \n");
    printf("\t\t\t\t7、销毁顺序栈                    8、清空顺序栈               \n");
    printf("\t\t\t\t9、检查顺序栈是否为空             10、顺序栈长度              \n");
    printf("\t\t\t\t11、字符串括号检查                0、退出操作系统            \n");
    printf("\t\t\tTips:请完成操作1和2之后再进行其余操作，否则程序会崩溃！          \n");
    printf("\t\t\t************************************************************\n");
}

void Menu_LinkStack()
{
    printf("\t\t\t*****************以下为链栈的菜单****************************\n");
    printf("\t\t\t\t1、建栈                         2、入栈                    \n");
    printf("\t\t\t\t3、出栈                         4、打印链栈                 \n");
    printf("\t\t\t\t5、取栈顶元素                    6、进制转换                \n");
    printf("\t\t\t\t7、销毁链栈                      8、清空链栈                \n");
    printf("\t\t\t\t9、检查链栈是否为空               10、链栈长度               \n");
    printf("\t\t\t\t11、字符串括号检查                0、退出操作系统            \n");
    printf("\t\t\tTips:请完成操作1和2之后再进行其余操作，否则程序会崩溃！          \n");
    printf("\t\t\t************************************************************\n");
}
//
// Created by somewon on 2022/10/1.
//

二、主函数调用文件(main.cpp)

#include <iostream>
#include <stdio.h>
#include "before.h"

using namespace std;

int main() {
    int CH,ch;
    int fine;
    ElemType e,ee;
    do {
        Menu();
        int des = ERR;     //记录栈是否被销毁
        cout << "请输入你的选择：";
        cin >> CH;
        if(CH == 1)        //顺序栈
        {
            SqStack S,M;
            int maxsize,con;
            do {
                Menu_SqStack();
                cout << "请输入你的选择：";
                cin >> ch;
                switch(ch)
                {
                    case 0:
                        goto ENDD;
                    case 1:
                        cout << "请输入顺序栈的最大容量：";
                        cin >> maxsize;
                        fine = InitStack(S,maxsize);
                        if(fine == OK)
                        {
                            cout << "建栈成功！" << endl;
                            des = ERR;
                        }
                        else cout << "建栈失败！" << endl;
                        break;
                    case 2:
                        cout << "请输入一个数据元素：" << endl;
                        cin >> e;
                        fine = Push_SqStack(S,e);
                        if(fine == OVERFLOW) cout << "入栈失败！该顺序栈已满！" << endl;
                        else if(fine == OK) cout << "当前元素入栈成功！" << endl;
                        PrintStack_SqStack(S);
                        break;
                    case 3:
                        fine = Pop_SqStack(S,e);
                        if(fine == ERR) cout << "空栈无法出栈元素！" << endl;
                        else
                        {
                            cout << e << endl;
                            PrintStack_SqStack(S);
                        }
                        break;
                    case 4:
                        PrintStack_SqStack(S);
                        break;
                    case 5:
                        fine = GetTop_SqStack(S);
                        if(fine == ERR) cout << "该顺序栈为空栈，无栈顶元素！" << endl;
                        else cout << "当前顺序栈的栈顶元素为：" << GetTop_SqStack(S) << endl;
                        break;
                    case 6:
                        cout << "请输入需要转换的进制(输入2-16的整数)为：";
                        cin >> con;
                        maxsize = 1000;
                        Conversion_SqStack(M,con,maxsize);
                        break;
                    case 7:
                        DestroySqStack(S);
                        cout << "顺序栈销毁成功！" << endl;
                        des = OK;
                        break;
                    case 8:
                        ClearSqStack(S);
                        cout << "顺序栈清空成功！" << endl;
                        break;
                    case 9:
                        if(des == OK) cout << "该顺序栈已被销毁！" << endl;
                        else
                        {
                            fine = StackEmpty_SqStack(S);
                            if(fine == OK) cout << "该顺序栈为空！" << endl;
                            else cout << "该顺序栈不为空！" << endl;
                        }
                        break;
                    case 10:
                        cout << "该顺序栈的长度为：" << StackLength_SqStack(S) << endl;
                        break;
                    case 11:
                        fine = Compare_SqStack();
                        if(fine == OK) cout << "输入的字符串括号匹配！" << endl;
                        else if(fine == OVERFLOW) cout << "栈满，无法进行判断！" << endl;
                        else cout << "输入的字符串括号不匹配!" << endl;
                        fflush(stdin);//清空缓冲区不必要的字符，防止带来不必要的类似死循环的错误
                        break;
                    default:
                        cout << "无该操作！" << endl;
                }
            }while(ch);
        }
        else if(CH == 2)  //链栈
        {
            LinkStack S,M;
            int num = 0;  //记录链表的长度
            int con;      //进制的存储
            do {
                Menu_LinkStack();
                int n;
                cout << "请输入你的选择：";
                cin >> ch;
                switch(ch)
                {
                    case 0:
                        goto ENDD;
                    case 1:
                        InitStack_LinkStack(S);
                        cout << "初始化栈成功！" << endl;
                        des = ERR;
                        break;
                    case 2:
                        cout << "请输入一个入栈元素：" << endl;
                        cin >> e;
                        Push_LinkStack(S,e);
                        num ++;
                        cout << "成功建立链栈！" << endl;
                        des = ERR;
                        PrintLinkStack(S);
                        break;
                    case 3:
                        if(S == NULL) cout << "空栈无法出栈元素！" << endl;
                        e = -1;
                        Pop_LinkStack(S,e);
                        num --;
                        cout << e << endl;
                        PrintLinkStack(S);
                        break;
                    case 4:
                        PrintLinkStack(S);
                        break;
                    case 5:
                        fine = GetTop_LinkStack(S);
                        if(fine == ERR) cout << "空栈无栈顶元素！" << endl;
                        else cout << "此时链栈的栈顶元素为：" << fine << endl;
                        break;
                    case 6:
                        cout << "请输入需要转换的进制(输入2-16的整数)为：";
                        cin >> con;
                        Conversion_LinkStack(M,con);
                        break;
                    case 7:
                        DestroyLinkStack(S);
                        cout << "销毁链栈成功！" << endl;
                        des = OK;
                        break;
                    case 8:
                        ClearLinkStack(S);
                        cout << "清空链栈成功！" << endl;
                        num = 0;
                        break;
                    case 9:
                        if(des == OK) cout << "该链栈已被销毁！" << endl;
                        else
                        {
                            fine = StackEmpty_LinkStack(S);
                            if(fine == OK) cout << "该链栈为空！" << endl;
                            else cout << "该链栈不为空！" << endl;
                        }
                        break;
                    case 10:
                        cout << "该链栈的元素个数为：" << StackLength_LinkStack(num) << endl;
                        break;
                    case 11:
                        fine = Compare_LinkStack();
                        if(fine == OK) cout << "输入的字符串括号匹配！" << endl;
                        else cout << "输入的字符串括号不匹配!" << endl;
                        fflush(stdin);//清空缓冲区不必要的字符
                        break;
                    default:
                        cout << "无该操作!" << endl;
                }
            }while(ch);
        }
        else if(CH == 0) goto END;
        else cout << "无该操作！\n" << endl;

        ENDD:
        printf("当前程序运行结束！\n");
    }while(CH);
    END:
    cout << "程序运行结束！欢迎您下次使用嘿哈！" << endl;
    return 0;
}
//
//Created by somewon on 2022/10/1.
//

三、头文件声明文件(before.h)

#ifndef _BEFORE_H
#define _BEFORE_H

#define OK 1
#define ERR 0
#define OVERFLOW (-1)

typedef int ElemType;
typedef int status;

typedef struct{
    ElemType *base;   //栈底指针
    ElemType *top;    //栈顶指针
    int numb;         //顺序栈个数
}SqStack;

//顺序栈相关功能函数声明
status InitStack(SqStack &S,int maxsize);     //建立空栈
void PrintStack_SqStack(SqStack S);           //打印顺序栈
status Push_SqStack(SqStack &S,ElemType e);   //入栈
status Pop_SqStack(SqStack &S,ElemType &e);   //出栈
status GetTop_SqStack(SqStack S);             //取栈顶元素
void DestroySqStack(SqStack &S);              //销毁顺序栈
void ClearSqStack(SqStack &S);                //清空顺序栈
status StackEmpty_SqStack(SqStack S);         //判断顺序栈是否为空
status StackLength_SqStack(SqStack S);        //顺序栈长度
void Conversion_SqStack(SqStack &M,int con,int maxsize);//数制转换
status Compare_SqStack();                     //括号匹配判断

typedef struct StackNode
{
    ElemType data;
    struct StackNode *next;
}StackNode,*LinkStack;

//链栈相关功能函数声明
void InitStack_LinkStack(LinkStack &S);       //初始化栈
void PrintLinkStack(LinkStack S);             //打印链栈
void Push_LinkStack(LinkStack &S,ElemType e); //入栈
void Pop_LinkStack(LinkStack &S,ElemType &e); //出栈
status GetTop_LinkStack(LinkStack S);         //取栈顶元素
void DestroyLinkStack(LinkStack &S);          //销毁链栈
void ClearLinkStack(LinkStack &S);            //清空链栈
status StackEmpty_LinkStack(LinkStack S);     //判断链栈是否为空
status StackLength_LinkStack(int &num);       //链栈长度
void Conversion_LinkStack(LinkStack &M,int con); //转换进制
status Compare_LinkStack();                   //字符串中的括号匹配判断

//相关菜单打印函数声明
void Menu();                                  //程序菜单
void Menu_SqStack();                          //顺序栈菜单
void Menu_LinkStack();                        //链栈菜单

#endif
//
// Created by somewon on 2022/10/1.
//

四、运行环境

Clion

Tips：注意若为dev编译环境，请将nullptr换为NULL；

猜你喜欢

转载自blog.csdn.net/somewon/article/details/127328470
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022