栈的顺序存储

---

 

分配一段连续的空间，用于存储数据。数据保持先进后出！

设置结构体表示栈的所有基本内容，stackSpace 作为指针指向一段连续的内存，获取位置用数组的下标表示。 stackSize表示一共分配多少空间，top表示最后元素的位置，top的前后移动表示数据的进出。

typedef struct seqStack {            //用结构体定义顺序栈
    int* stackSpace;                //栈空间的具体实现，通过动态申请空间创建数组
    int stackSize;                    //栈的大小，当为0时表示栈未创建
    int top;                        //栈顶位置，当为-1时栈为空
}STACK;                                //把定义的栈命名为STACK

以下是完整代码：

#include<stdio.h>
#include<stdio.h>
#include<windows.h>
#include<stdbool.h>
typedef struct seqStack {            //用结构体定义顺序栈
    int* stackSpace;                //栈空间的具体实现，通过动态申请空间创建数组
    int stackSize;                    //栈的大小，当为0时表示栈未创建
    int top;                        //栈顶位置，当为-1时栈为空
}STACK;                                //把定义的栈命名为STACK


//函数声明
void initStack(STACK* st);            //首次初始化一个栈
bool create(STACK* st,int size);    //实现创建一个栈，能容纳size个元素
void destroy(STACK* st);            //销毁一个栈
bool isEmpty(STACK* st);            //判断栈是否为空
bool isFull(STACK* st);                //判断栈是都为满
bool push(STACK* st,int* item);        //数据进栈
bool pop(STACK* st, int* item);        //出栈，完成是否出栈成功和出栈的值
bool getTop(STACK* st,int *item);   //取出当前栈顶数据
void traverse(STACK* st);            //遍历栈中所有数据
void clearscreen(void);             //清屏
void showmenu();                    //显示菜单
void processmenu(STACK* st);                 //处理菜单窗口

//主函数
int main() {
    SetConsoleTitle("栈元素的简单操作");
    system("color f0");                  //设置背景为白色，字体为黑色
    clearscreen();
    STACK st;
    while (true) {
        showmenu();                     //显示菜单
        processmenu(&st);                  //处理菜单窗口，出口就在其中
        system("pause");                //暂停一下，等用户给一个回车
        clearscreen();
    }
    return 0;
}

//显示菜单
void showmenu() {
    puts("=============================================    ");
    puts("栈的简单操作 ");
    puts("=============================================    ");
    puts("                   ★功能菜单★                    ");
    puts("=============================================    ");
    puts("1.创建一个栈（请输入创建栈的元素个数）            ");
    puts("2.销毁一个栈                                    ");
    puts("3.出栈并且返回原栈顶的值                        ");
    puts("4.取出当前栈顶元素                                ");
    puts("5.遍历栈中所有数据                                ");
    puts("6.数据进栈                                        ");
    puts("0.结束程序                                        ");
    puts("=============================================    ");
    printf("请输入您的选择：");
}

//处理菜单窗口
void processmenu(STACK* st) {
    int menuchoice;
    int num1;
    bool returnvalue;
    scanf("%d", &menuchoice);
    switch (menuchoice) {
    case 1:                                //创建一个栈
        printf("请输入要创建栈的元素个数：");
        scanf("%d",&num1);
        initStack(st);
        returnvalue = create(st,num1);
        if (returnvalue == false) {
            printf("创建栈失败！");
        }
        else {
            printf("创建栈成功！");
        }
        break;
    case 2:                                    //销毁一个栈
        destroy(st);
        printf("栈销毁成功！");
        break;
    case 3:                                    //出栈
        returnvalue = pop(st,&num1);
        if (returnvalue == false) {
            printf("出栈失败！");
        }
        else {
            printf("出栈成功！栈顶元素为%d",num1);
        }
        break;
    case 4:                                    //获取栈顶的值
        returnvalue = getTop(st,&num1);
        if (returnvalue == false) {
            printf("获取值失败！");
        }
        else {
            printf("栈顶的元素是:%d",num1);
        }
        break;
    case 5:
        traverse(st);
        break;
    case 6:
        printf("请输入您要入栈的值：");
        scanf("%d",&num1);
        returnvalue = push(st,&num1);
        if (returnvalue == false) {
            printf("数据出栈错误！");
        }
        else {
            printf("数据进栈成功！");
        }
        break;
    case 0:
        puts("
您已经成功退出本系统，欢迎再次使用！！！");
        system("pause");
        exit(1);
    default:
        puts("对不起，您输入的功能编号有错！请重新输入！！！");
        break;
    }
}

//清屏
void clearscreen(void) {
    system("cls");
}

//初始化一个栈
void initStack(STACK* st) {
    st->stackSpace = NULL;
    st->stackSize = 0;                //栈的大小，初始值为0，表示目前还没有建立
    st->top = -1;                    //栈顶位置，当为-1时，栈为空
}

//创建一个栈空间
bool create(STACK* st, int size) {
    if (st->stackSize) {                    //先判断栈是否已经创建
        return false;                        
    }
    if (size <= 0) {                        //判断给出的大小是否合适
        return false;
    }
    st->stackSpace = (int*)malloc(sizeof(int) * size);
    if (st->stackSpace == NULL) {            //判断是否分配内存成功
        return false;
    }

    st->stackSize = size;                    
    st->top = -1;                            //刚创建时栈为空，指向-1
    return true;
}

//销毁一个栈
void destroy(STACK* st) {
    if (st->stackSpace) {
        free(st->stackSpace);
    }
    st->stackSpace = NULL;
    st->stackSize = 0;
    st->top = -1;
}

//出栈
bool pop(STACK* st, int* item) {
    if (isEmpty(st)) {
        return false;
    }
    *item = st->stackSpace[st->top];
    st->top--;
    return true;
}

//判断栈是否为空
bool isEmpty(STACK* st) {
    if (st->stackSize == 0) {
        return true;
    }
    return st->top == -1 ? true : false;
}

//获取栈顶的值
bool getTop(STACK* st, int* item) {
    if (isEmpty(st)) {
        return false;
    }
    *item = st->stackSpace[st->top];
    return true;
}

//遍历栈中所有元素
void traverse(STACK* st) {
    if (st->stackSize == 0) {
        printf("栈尚未建立！
");
    }
    else {
        printf("目前栈中的内容是：");
        printf("栈底■");
        for (int i = 0; i <= st->top; i++) {
            printf("%d ",st->stackSpace[i]);
        }
        printf("←top栈顶
");
    }
}

//数据入栈
bool push(STACK* st, int* item) {
    if (st->stackSize == 0) {
        return false;
    }
    if (isFull(st)) {
        return false;
    }
    st->top++;
    st->stackSpace[st->top] = *item;

    return true;
}

//判断栈内容是否为满
bool isFull(STACK* st) {
    if (st->stackSize == 0) {                    //没有创建视为满
        return true;
    }
    return (st->top) == (st->stackSize) - 1 ? true : false;
}