三、《---详解顺序栈---》

已于 2023-10-19 20:00:08 修改
阅读量90 收藏
点赞数
文章标签： 数据结构 开发语言
于 2023-10-18 21:03:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61786342/article/details/133914024
版权

目录

一、顺序栈的定义

二、顺序栈的运算

三、顺序栈的实现

四、完整代码

五、运行结果截图

六、总结

七、参考文献

一、顺序栈的定义

顺序栈是栈的顺序实现。遵循先进后出原则，顺序栈是指利用顺序存储结构实现的栈。采用地址连续的存储空间（数组)依次存储栈中数据元素，由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处；栈顶位置是随入栈和出栈操作而变化的，所以需用一个整型变量top来记录当前栈顶元素在数组中的位置，

二、顺序栈的运算

  1. 入栈（Push）：在栈顶位置插入一个元素。
  2. 出栈（Pop）：删除栈顶元素并返回其值。
  3. 查看栈顶元素（Peek/Top）：返回栈顶元素的值但不删除它。
  4. 判断栈是否为空（IsEmpty）：如果栈为空则返回True，否则返回False。
  5. 判断栈是否已满（IsFull）：如果栈已满则返回True，否则返回False。
  6. 栈的应用

三、顺序栈的实现

1、栈的初始化

/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
    /*申请内存空间*/
    S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);

    if(!S->data)
    {
        printf("内存申请错误，初始化失败！[10001]\n");
        return 10001;
    }
    S->maxsize = MaxSize;
    S->top = -1;
    return 0;
}

2、入栈


/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
    /*是否满？*/
    if(full(S))
    {
        printf("栈已满！10002\n");
        return 10002;
    }

    S->top++;            /*移动指针*/
    S->data[S->top] = x;/*放入数据*/
    return 0; /*OK*/
}

3、出栈


/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
    /*是否空？*/
    if(empty(S))
    {
        printf("栈为空！10003\n");
        return 10003;
    }

    *x = S->data[S->top];    /*栈顶元素赋值给x*/
    S->top--;                /*移动栈顶指针*/    

    return 0;
}

4、取栈顶元素


/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
    /*是否空？*/
    if(empty(S))
    {
        printf("栈为空！10003\n");
        return 10003;
    }

    *x = S->data[S->top];    /*栈顶元素赋值给x*/

    return 0;
}

5、栈是否为空？


/* 5. 栈为空？*/
int empty(SeqStack *S)
{
    return (S->top == -1)?1:0;
}

6、栈是否已满？

/* 6. 栈满？*/
int full(SeqStack *S)
{
    return (S->top == S->maxsize - 1)?1:0;
}
 

7、销毁栈


/* 7. 销毁*/
int destroy(SeqStack *S)
{
    free(S->data);
    return 0;
}

8、栈的应用（十进制转二进制、后缀运算）

/*十进制转换为二进制*/
int d_to_b(int d)
{
    SeqStack S;
    int b;

    /*初始化栈*/
    init(&S,32);

    /*d不为0，余数进栈*/
    while(d)
    {
        push(&S, d % 2);
        d /= 2;
    }
    
    /*依次出栈*/
    while(!empty(&S))
    {
        pop(&S,&b);
        printf("%d", b);
    }

    /*销毁栈*/
    destroy(&S);
}


/*后缀表达式计算*/
int expression()
{
    SeqStack S;
    int i;
    int op1, op2;    
    int x;

    char exp[20]; /*后缀表达式*/

    init(&S, 10);

    printf("请输入一个后缀表达式(eg. 56+):");
    scanf("%s", exp);

    for(i=0;i<strlen(exp);i++)
    {
        switch(exp[i])
        {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            /*入栈*/
            push(&S, exp[i]-48);
            break;
        case '+':
            /*出2个*/
            pop(&S, &op1);
            pop(&S, &op2);
            x = op1 + op2;
            push(&S, x);
            break;

        case '*':
            pop(&S, &op1);
            pop(&S, &op2);
            x = op1 * op2;
            push(&S, x);
            break;

        case '-':
            pop(&S, &op1);
            pop(&S, &op2);
            x = op1 - op2;
            push(&S, x);
            break;

        case '/':
            pop(&S, &op1);
            pop(&S, &op2);
            x = op1 / op2;
            push(&S, x);
            break;
        }
    }
    pop(&S, &x);
    printf("计算结果为：%s = %d\n", exp, x);
    destroy(&S);
}

四、完整代码

1.main.c

#include <stdio.h>
#include <string.h>
#include "seqstack.h"
#include "welcome.h"


/*十进制转换为二进制*/
int d_to_b(int d);

/*后缀表达式计算*/
int expression();
int main(int argc, char* argv[])
{
    SeqStack S;
    int i,d,m,n,cmd;
    DataType x;
    int maxsize;
    char yn;

    for(i=0;i<strlen(welcome);i++)
    {
        printf("%c",welcome[i]);
        for(m=0;m<1000;m++)
            for(n=0;n<1000;n++)
            {
                ;
            }
    }

    
    do
    {
        printf("---------顺序栈演示程序-----------\n");
        printf(" 1. 初始化\n");
        printf(" 2. 入栈\n");
        printf(" 3. 出栈\n");
        printf(" 4. 查看栈顶元素\n");
        printf(" 5. 判断栈是否为空\n");
        printf(" 6. 判断栈是否满\n");
        printf(" 7. 销毁栈\n");
        printf(" 8. 栈的应用\n");
        printf(" 9. 帮助\n"); 
        printf("请选择（0~9,0退出)：");
        scanf("%d", &cmd);
        switch(cmd)
        {
        case 1:
            printf("请输入栈的最大存储空间(MaxSize)：");
            scanf("%d", &maxsize);
            if(!init(&S, maxsize))
            {
                printf("栈已初始化！\n");
            }
            break;
        case 2:
            printf("请输入入栈元素：x=");
            scanf("%d", &x);
            if(!push(&S, x))
            {
                printf("元素【%d】已入栈！\n", x);

            }
            break;
        case 3:
            printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
            flushall();
            scanf("%c", &yn);
            if(yn == 'y' || yn == 'Y')
            {
                if(!pop(&S, &x))
                {
                    printf("栈顶元素【%d】已出栈！\n", x);
                }
            }

            break;
        case 4:
            printf("取栈顶元素：x=【%d】",x);
            break;
        case 5:
            if(empty(&S)){
                printf("栈为空\n");
            }else{
                printf("栈不为空\n");
            }
            break;
        case 6:
            if(full(&S)){
                  printf("栈已满\n");
            }else{
                  printf("栈未满\n");
            }
            break;
        case 7: 
            destroy(&S); // 销毁栈  
            printf("栈已销毁");
            break;
        case 8:
            do
            {
                printf("----------8.栈的应用------------\n");
                printf(" 1. 十进制转换为二进制\n");
                printf(" 2. 后缀表达式计算\n");            
                printf(" 0. 返回\n");
                printf("请选择：");
                scanf("%d", &cmd);

                if(cmd == 1)
                {
                    printf("请输入一个十进制数：");
                    scanf("%d", &d);
                    printf("二进制为：");
                    d_to_b(d);
                    printf("\n");
                }

                if(cmd == 2)
                {
                    expression();
                }
            }while(cmd!=0);
            cmd = -1;
            break;
        case 9:
            printf("^^^^^^^本程序为顺序栈的演示程序，由林振发设计开发，程序完成了入栈、出栈、取栈顶、判断栈是否为空、销毁栈、栈的扩容等功能!^^^^^^\n");
            break;
        }
    }while(cmd!=0);

    return 0;
}

/*十进制转换为二进制*/
int d_to_b(int d)
{
    SeqStack S;
    int b;

    /*初始化栈*/
    init(&S,32);

    /*d不为0，余数进栈*/
    while(d)
    {
        push(&S, d % 2);
        d /= 2;
    }
    
    /*依次出栈*/
    while(!empty(&S))
    {
        pop(&S,&b);
        printf("%d", b);
    }

    /*销毁栈*/
    destroy(&S);
}


/*后缀表达式计算*/
int expression()
{
    SeqStack S;
    int i;
    int op1, op2;    
    int x;

    char exp[20]; /*后缀表达式*/

    init(&S, 10);

    printf("请输入一个后缀表达式(eg. 56+):");
    scanf("%s", exp);

    for(i=0;i<strlen(exp);i++)
    {
        switch(exp[i])
        {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            /*入栈*/
            push(&S, exp[i]-48);
            break;
        case '+':
            /*出2个*/
            pop(&S, &op1);
            pop(&S, &op2);
            x = op1 + op2;
            push(&S, x);
            break;

        case '*':
            pop(&S, &op1);
            pop(&S, &op2);
            x = op1 * op2;
            push(&S, x);
            break;

        case '-':
            pop(&S, &op1);
            pop(&S, &op2);
            x = op1 - op2;
            push(&S, x);
            break;

        case '/':
            pop(&S, &op1);
            pop(&S, &op2);
            x = op1 / op2;
            push(&S, x);
            break;
        }
    }
    pop(&S, &x);
    printf("计算结果为：%s = %d\n", exp, x);
    destroy(&S);
}

2.seqstack.c

/*
    seqstack.c

*/
#include "seqstack.h"


/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
    /*申请内存空间*/
    S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);

    if(!S->data)
    {
        printf("内存申请错误，初始化失败！[10001]\n");
        return 10001;
    }
    S->maxsize = MaxSize;
    S->top = -1;
    return 0;
}


/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
    /*是否满？*/
    if(full(S))
    {
        printf("栈已满！10002\n");
        return 10002;
    }

    S->top++;            /*移动指针*/
    S->data[S->top] = x;/*放入数据*/
    return 0; /*OK*/
}

/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
    /*是否空？*/
    if(empty(S))
    {
        printf("栈为空！10003\n");
        return 10003;
    }

    *x = S->data[S->top];    /*栈顶元素赋值给x*/
    S->top--;                /*移动栈顶指针*/    

    return 0;
}

/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
    /*是否空？*/
    if(empty(S))
    {
        printf("栈为空！10003\n");
        return 10003;
    }

    *x = S->data[S->top];    /*栈顶元素赋值给x*/

    return 0;
}

/* 5. 栈为空？*/
int empty(SeqStack *S)
{
    return (S->top == -1)?1:0;
}

/* 6. 栈满？*/
int full(SeqStack *S)
{
    return (S->top == S->maxsize - 1)?1:0;
}


/* 7. 销毁*/
int destroy(SeqStack *S)
{
    free(S->data);
    return 0;
}

3.seqstack.h

/*
    seqstack.h
    顺序栈
*/

typedef int DataType;


typedef struct
{
    DataType *data; /* 堆空间 */
    int maxsize;
    int top;        /* 栈顶指针 */
}SeqStack;


/* 1. 初始化 */
int init(SeqStack *S, int MaxSize);

/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x);

/* 3. 出栈 */
int pop(SeqStack *S, DataType *x);

/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x);

/* 5. 栈为空？*/
int empty(SeqStack *S);

/* 6. 栈满？*/
int full(SeqStack *S);

/* 7. 销毁*/
int destroy(SeqStack *S);

4.welcome.h

 char welcome[]=(
    "         lovelove                   lovelove\n"
    "       lovelovelove               lovelovelove\n"
    "     lovelovelovelove           lovelovelovelove\n"
    "   lovelovelovelovelove       lovelovelovelovelove\n"
    "  lovelovelovelovelovelo     lovelovelovelovelovele\n"
    " lovelovelovelovelovelovelolovelovelovelovelovelovee\n"
    "  lovelovelovelovelovelolovellovelovelovelovelovele\n"
    "   lovelovelovelovelovelovelolovelovelovelovelove\n"
    "     lovelovelovelovelovelovelovloveloveloveloe\n"
    "       lovelovelovelovelovelovelovloveloveloe\n"
    "         lovelovelovelovelolovelovelloveloe\n"
    "           lovelovelovelovelovelovelovele\n"
    "             lovelovelovelovelovelocele\n"
    "               lovelovelovelovelovele\n"
    "                 lovelovelovelovele\n"
    "                   loveloveloveve\n"
    "                     lovelovelo\n"
    "                       lovelov\n"
    "                         love\n"
    "                          爱\n"

    );
 

五、运行结果截图

六、总结

顺序栈是一种基础的数据结构，其核心特点如下：

  1. 后进先出：这是栈的基本特性，最后一个放入栈的元素第一个被取出。
  2. 动态内存分配：栈通常不需要在创建时分配所有的内存空间，而是在需要添加元素时动态分配，这也使得我们可以根据需要动态调整栈的大小。
  3. 存取效率高：因为栈只允许在一端（栈顶）进行添加或者删除操作，所以存取效率非常高。

七、参考文献

  1. 数据结构c语言版本（李刚）
  2. 百度查询
  3. csdn博客
一万里晴空60
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值