zoukankan      html  css  js  c++  java
  • 栈的顺序存储


     

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

    设置结构体表示栈的所有基本内容,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;
    }

     

  • 相关阅读:
    js获取数组最大值或最小值
    echarts 在 vue-awesome-swiper中无法点击
    vue 父子父组件通过props传父页面请求后的数据
    vue 路由对象
    popupwindow
    数据库
    冒泡排序
    xtuils
    版本更新
    清除缓存
  • 原文地址:https://www.cnblogs.com/WineinSeptember/p/12783150.html
Copyright © 2011-2022 走看看