【数据结构】顺序栈

栈是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶，相应地，表头端称为栈底。

顺序栈是指利用顺序存储结构实现的栈，即利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置。

谨以此文记录顺序栈的实现：

#include <iostream>

using namespace s
td;

#define MAXSIZE 100

typedef int SElemType;

typedef struct
{
    SElemType *base = nullptr;
    SElemType *top = nullptr;
    int stacksize;
} SqStack;

void printUI()
{
    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 << "*********  11.数制转换                        *********" << endl;
    cout << "*********  12.退出                            *********" << endl;
    cout << "*******************************************************" << endl;
}

/**
 * @brief 初始化栈
 *
 * @param S
 * @return true
 * @return false
 */
bool InitStack(SqStack &S)
{
    S.base = new SElemType[MAXSIZE];
    S.top = S.base;
    S.stacksize = MAXSIZE;
    return true;
}

/**
 * @brief 判断栈是否为空
 *
 * @param S
 * @return true
 * @return false
 */
bool StackEmpty(SqStack S)
{
    if (S.top == S.base)
        return true;
    return false;
}

/**
 * @brief 求顺序栈的长度
 *
 * @param S
 * @return int
 */
int StackLength(SqStack S)
{
    return S.top - S.base;
}

/**
 * @brief 清空栈
 *
 * @param S
 * @return true
 * @return false
 */
bool ClearStack(SqStack &S)
{
    if (S.base)
        S.top = S.base;
    return true;
}

/**
 * @brief 销毁栈
 *
 * @param S
 * @return true
 * @return false
 */
bool DestroyStack(SqStack &S)
{
    if (S.base)
    {
        delete[] S.base;
        S.stacksize = 0;
        S.base = S.top = nullptr;
    }
    return true;
}

/**
 * @brief 入栈
 *
 * @param S
 * @param e
 * @return true
 * @return false
 */
bool Push(SqStack &S, SElemType e)
{
    if (S.top - S.base == S.stacksize)
        return false;
    *S.top++ = e;
    return true;
}

/**
 * @brief 出栈
 *
 * @param S
 * @param e
 * @return true
 * @return false
 */
bool Pop(SqStack &S, SElemType &e)
{
    if (S.top == S.base)
        return false;
    e = *--S.top;
    return true;
}

/**
 * @brief 取栈顶元素
 *
 * @param S
 * @param e
 * @return true
 * @return false
 */
bool GetTop(SqStack S, SElemType &e)
{
    if (S.top == S.base)
        return false;
    e = *(S.top - 1);
    return true;
}

/**
 * @brief 输出栈元素
 *
 * @param S
 * @return true
 * @return false
 */
bool PrintElem(SqStack S)
{
    if (S.top == S.base)
        return false;
    for (SElemType *p = S.top - 1; p >= S.base; p--)
    {
        cout << *p;
        if (p == S.base)
            cout << endl;
        else
            cout << " ";
    }
    return true;
}

/**
 * @brief 十进制转二进制
 *
 * @param num
 */
void Dec2Bin(int num)
{
    SqStack stack;
    SElemType e;
    InitStack(stack);
    while (num > 0)
    {
        Push(stack, num % 2);
        num /= 2;
    }
    while (Pop(stack, e))
        cout << e;
    cout << endl;
}

int main()
{
    int mode, i;
    SqStack S;
    SElemType e;
    printUI();
    while (true)
    {
        cout << "请输入选择：";
        cin >> mode;
        if (mode == 12)
            break;
        if (mode < 1 || mode > 12)
            continue;
        if (!S.base && mode != 1 && mode != 10)
        {
            cout << "尚未初始化" << endl;
            continue;
        }
        switch (mode)
        {
        case 1:
            if (InitStack(S))
                cout << "初始化成功" << endl;
            break;
        case 2:
            if (DestroyStack(S))
                cout << "销毁成功" << endl;
            break;
        case 3:
            if (ClearStack(S))
                cout << "清空成功" << endl;
            break;
        case 4:
            if (StackEmpty(S))
                cout << "栈为空" << endl;
            else
                cout << "栈不为空" << endl;
            break;
        case 5:
            cout << "栈的长度为" << StackLength(S) << endl;
            break;
        case 6:
            if (GetTop(S, e))
                cout << "栈顶元素为" << e << endl;
            else
                cout << "获取栈顶元素失败" << endl;
            break;
        case 7:
            cout << "请输入你要插入的元素：";
            cin >> e;
            if (Push(S, e))
                cout << "入栈成功" << endl;
            else
                cout << "入栈失败" << endl;
            break;
        case 8:
            if (Pop(S, e))
                cout << "元素" << e << "出栈成功" << endl;
            else
                cout << "出栈失败" << endl;
            break;
        case 9:
            if (!PrintElem(S))
                cout << "栈内无元素" << endl;
            break;
        case 10:
            int n;
            cout << "请输入要输入的元素个数：";
            cin >> n;
            if (n > MAXSIZE)
            {
                cout << "超出容量" << endl;
                break;
            }
            InitStack(S);
            while (n--)
            {
                cin >> e;
                Push(S, e);
            }
            break;
        case 11:
            int num;
            cout << "请输入你要转换的十进制数：";
            cin >> num;
            Dec2Bin(num);
            break;
        }
    }
    return 0;
}