数据结构 实验4 顺序栈的基本操作及应用

实验内容：

　　实验4、顺序栈的基本操作及应用 

　　（1）实验目的

　　　　通过该实验，让学生掌握栈的相关基本概念，认识栈是插入和删除集中在一端进行的线性结构，掌握栈的“先入后出”操作特点。栈在进行各类操作时，栈底指针固定不动，掌握栈空、栈满的判断条件。

　　（2）实验内容

　　　　用顺序存储结构，实现教材定义的栈的基本操作，提供数制转换功能，将输入的十进制整数转换成二进制、八进制或十六进制。

　　（3）参考界面

　　菜单中包括以下功能：

　　　　1.初始化栈，2.销毁栈，3.清空栈，4.栈判空，5.求栈长度，6.获取栈顶元素，7.插入一个 元素，8.删除一个元素，9输出所有元素，10进制转换。

　　要求：自定义的函数中不允许出现提示语和输出语句。

　　（4）验收/测试用例

　　通过菜单调用各个操作，测试点：

　　　　l 没有初始化前进行其他操作，程序是否能控制住；

　　　　l 初始化一个栈；

　　　　l 判栈空，屏幕显示栈为空；

　　　　l 3个数入栈， 2、4、6；

　　　　l 栈长度，屏幕输出3；

　　　　l 取栈顶元素，再判栈空，然后再判栈长度。让学生知道取栈顶元素不改变栈中的内容，栈顶指针不发生改变；

　　　　l 出栈，再判栈长度和输出栈中内容；（多次出栈，直到栈为空；再出栈，是否提示栈为空）

　　　　l 销毁栈，再做其他操作，判断程序是否能控制；

　　　　数制转换，（允许用户输入想把十进制转换成几进制），然后灵活的转换成对应的进制。

实验环境：

　　VS2019

设计思想

　　1.设置主函数类main.cpp进行菜单的展示和执行，设置头文件stuck.h存放函数和构造体声明，设置功能函数类stuck.cpp存放功能函数；

　　2.每个函数调用前判断栈是否初始化，个别函数之后仍需判断栈是否为空；

　　3.菜单展示和执行使用while循环，每次循环前进行清屏，提高用户体验；

　　4.进制转换：

          可以进行十以内进制包括十六进制的转换，在进行十六进制转换输出时，判断元素＞9则输出相应的字母，否则直接输出；程序使用过后释放内存； 增加对输入数为0的判断；

　　5.直接退出程序先调用销毁函数释放内存空间；

二、主要源代码

main.cpp

#include "stack.h" //引入自定义头文件
int main()
{
    Stuck stuck;
    stuck.base = NULL;
    Stuck trans_stuck;        //进制转换所需栈
    trans_stuck.base = NULL;
    int position;
    while (true)
    {
        system("cls");
        cout << "欢迎使用本程序" << endl;
        cout << "1. 初始化栈" << endl;
        cout << "2. 销毁栈" << endl;
        cout << "3. 清空栈" << endl;
        cout << "4. 栈判空" << endl;
        cout << "5. 求栈长度" << endl;
        cout << "6. 获取栈顶元素" << endl;
        cout << "7. 插入一个元素" << endl;
        cout << "8. 删除一个元素" << endl;
        cout << "9. 输出所有的元素" << endl;
        cout << "10.进制转换" << endl;
        cout << "请输入指令完成操作" << endl;
        cin >> position;
        if (position < 0)
        {
            cout << "谢谢您的使用" << endl;
            destoryStuck(stuck);          //结束时释放栈内存空间
            break;
        }
        switch (position)
        {
        case 1:
            if (stuck.base)
            {
                cout << "请进行销毁操作后再初始化" << endl;
            }
            else
            {
                initializeStuck(stuck);
                if (stuck.base)
                    cout << "初始化成功" << endl;
                else
                    cout << "初始化失败" << endl;
            }
            system("pause"); break;
        case 2:
            if (stuck.base)
            {
                destoryStuck(stuck);
                if (stuck.base)
                    cout << "销毁失败" << endl;
                else
                    cout << "销毁成功" << endl;
            }
            else
            {
                cout << "请初始化后再进行销毁" << endl;
            }
            system("pause"); break;
        case 3:
            if (stuck.base)
            {
                emptyStuck(stuck);
                if (ifEmpty(stuck))
                    cout << "清空失败" << endl;
                else
                    cout << "清空成功" << endl;
            }
            else
            {
                cout << "请初始化后再进行清空操作" << endl;
            }
            system("pause"); break;
        case 4:
            if (stuck.base)
            {
                if (ifEmpty(stuck))
                    cout << "栈不为空" << endl;
                else
                    cout << "栈为空" << endl;
            }
            else
            {
                cout << "请初始化后再进行此操作" << endl;
            }
            system("pause"); break;
        case 5:
            if (stuck.base)
            {
                
                cout << "该栈的长度为： " <<(stuck.top - stuck.base) << endl;
            }
            else
            {
                cout << "请初始化后再进行此操作" << endl;
            }
            system("pause"); break;
        case 6:
            if (stuck.base)
            {
                if(ifEmpty(stuck))
                {
                    cout << " 栈顶元素为：" << getTop(stuck) << endl;
                }
                else
                    cout << "请插入元素后再进行此操作" << endl;
            }
            else
                cout << "请初始化后再进行此操作" << endl;
            system("pause"); break;
        case 7:
            if (stuck.base)
            {
                if((stuck.top-stuck.base)==stuck.stacksize)
                { 
                    cout << "栈已满，正在申请新的内存空间" << endl;
                    stuck.base = (element*)realloc(stuck.base,(STACKINCREMENT + STACK_INIT_SIZE) * sizeof(element));
                    if (stuck.base)
                    {
                        stuck.top = stuck.stacksize + stuck.base;
                        stuck.stacksize += STACKINCREMENT;
                    }
                    else
                    {
                        cout << "申请失败，请联系管理员" << endl;
                    }
                }
                else {
                    element elem;
                    cout << "请输入要插入的元素" << endl;
                    cin >> elem;
                    insertElem(stuck,elem);
                }
            }
            else
                cout << "请初始化后再进行此操作" << endl;
            system("pause"); break;
        case 8:
            if (stuck.base)
            {
                if (ifEmpty(stuck))
                    deleteElem(stuck);
                else {
                    cout<< "请添加元素后再进行删除操作" << endl;
                }
            }
            else
            {
                cout << "请初始化后再进行此操作" << endl;
            }
            system("pause"); break;
        case 9:
            if (stuck.base)
            {
                if (ifEmpty(stuck))
                {
                    cout << "目前元素为：" << endl;
                    printElem(stuck);
                }
                else
                    cout << "栈为空" << endl;
            }
            else
                cout << "请初始化后再进行此操作" << endl;
            system("pause"); break;
        case 10:
            int num;
            int num_system;
            initializeStuck(trans_stuck); 
                cout << "请输入要转换的十进制数： " << endl;
                cin >> num;
                cout << "请输入要转换的数制" << endl;
                cin >> num_system;
                if(num == 0)           //判断输入数为0的情况
                    cout<<num << "的" << num_system << "进制为：" <<0<< endl;
                else if ((num_system > 10 && num_system != 16) || num_system < 2) 
                {
                    cout << "暂时不支持此进制的转换" << endl;
                }
                else
                {
                    cout << num << "的" << num_system << "进制为：" << endl;
                    initializeStuck(trans_stuck);
                    while (num != 0)
                    {
                        int remainder = num % num_system;  
                        insertElem(trans_stuck, remainder);//将余数压入栈中
                        num = num / num_system;            
                    }
                    if (num_system == 16)      //当转换进制为16时
                    { 
                        while (trans_stuck.base != trans_stuck.top)
                        {
                            int choice = *(--trans_stuck.top);
                            switch (choice)
                            {
                            case 10:cout << "A"; break;
                            case 11:cout << "B"; break;
                            case 12:cout << "C"; break;
                            case 13:cout << "D"; break;
                            case 14:cout << "E"; break;
                            case 15:cout << "F"; break;
                            default:cout << choice; break;
                            }
                        }
                    }
                    else
                    printElem(trans_stuck);
                }
                destoryStuck(trans_stuck); //释放内存空间
                system("pause"); break;
        }
    }
}

studck.h

#pragma once
#include <iostream>
using namespace std;
#define STACK_INIT_SIZE 100  
#define STACKINCREMENT 10
typedef int element;
typedef struct 
{
    element *base;    //栈底指针
    element *top;     //栈顶指针
    int stacksize;    // 当前已分配的存储空间
}Stuck;
void initializeStuck(Stuck &stuck); //初始化
void destoryStuck(Stuck& stuck);    //销毁
void emptyStuck(Stuck& stuck);      //清空
bool ifEmpty(Stuck stuck);          //判断是否为空
element getTop(Stuck stuck);        //获取栈顶元素
void insertElem(Stuck& stuck,element elem);      //插入元素
void deleteElem(Stuck& stuck);      //删除元素
void printElem(Stuck stuck);      //输出所有元素

stuck.cpp

#include "stack.h"   //引入头文件
//1 初始化栈
void initializeStuck(Stuck& stuck)
{
    stuck.base = (element*)malloc(STACK_INIT_SIZE * sizeof(element));
    stuck.top = stuck.base;
    stuck.stacksize = STACK_INIT_SIZE;
}
// 2 销毁栈
void destoryStuck(Stuck& stuck)
{
    free(stuck.base);
    stuck.stacksize = 0;
    stuck.top = NULL;
    stuck.base = NULL;
}
// 3 清空栈
void emptyStuck(Stuck& stuck)
{
    stuck.top = stuck.base;
}
// 4 判断栈是否为空
bool ifEmpty(Stuck stuck)
{
    if (stuck.top == stuck.base)
        return false;
    else
        return true;
}
// 6 获取栈顶元素
element getTop(Stuck stuck)
{
    /*int pos = (stuck.top - stuck.base) - 1; 
    return stuck.base[pos];*/
    return *(--stuck.top);
}
// 7 插入元素
void insertElem(Stuck& stuck, element elem)
{
    //较麻烦，不推荐使用已注释的方法
    /*int pos = stuck.top - stuck.base;
    stuck.base[pos] = elem;
    stuck.top++;*/
    *(stuck.top++) = elem;
}
// 8 删除元素
void deleteElem(Stuck& stuck)
{
    stuck.top--;
}
// 9 输出所有元素
void printElem(Stuck stuck)
{
    while (stuck.base != stuck.top)
    {
        cout << *(--stuck.top) << " ";
    }
    cout << endl;
    //这种方法也可以使用，二者先选其一即可；
    /*for (int i = 0; i < (stuck.top - stuck.base); i++)
    {
        cout << stuck.base[i] << " ";
    }
    cout << endl;*/
}

实验结果总结

 

 

 

 

 

 

 在未进行初始化前不可进行其它操作

 

 

 

 

 

 

 

 

 

 初始化后栈为空，长度为0，不可获取栈顶元素也不能进行删除操作，输出元素则会提示栈为空；

 

 

插入两个数

 

 

 

 求栈长

 

 输出当前元素

 

 

 

 删除一个元素并检查栈长，输出所有元素

 

 获取栈顶元素

 

 

销毁栈

 

 

 

 

 

 数制转换测试

 

 输入负数退出程序（忘记在菜单中添加了，加上下面这条语句：cout << "输入负数退出程序" << endl;）

 实验结果的运用：

　　1.熟悉了顺序栈的基本操作和运行原理；

　　2.对于16进制转换时，可以在输出时进行处理，因此并不妨碍进栈操作的进行；

　　3.在进行出栈操作时进行栈是否为空的判断，同时进栈时考虑分配的空间满的情况下，进行内存扩容。

 

 

进行实验时参考了以下内容：

 https://blog.csdn.net/qq_24654501/article/details/109273418?ops_request_misc=&request_id=&biz_id=102&utm_term=%E7%94%A8%E9%A1%BA%E5%BA%8F%E5%AD%98%E5%82%A8%E7%BB%93%E6%9E%84%EF%BC%8C%E5%AE%9E%E7%8E%B0%E6%95%99%E6%9D%90%E5%AE%9A%E4%B9%89%E7%9A%84%E6%A0%88%E7%9A%84%E5%9F%BA%E6%9C%AC%E6%93%8D%E4%BD%9C%EF%BC%8C%E6%8F%90%E4%BE%9B%E6%95%B0%E5%88%B6%E8%BD%AC%E6%8D%A2%E5%8A%9F%E8%83%BD&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-109273418.pc_search_result_hbase_insert&spm=1018.2226.3001.4187