《顺序栈讲解》

最新推荐文章于 2024-11-10 23:39:48 发布
最新推荐文章于 2024-11-10 23:39:48 发布
阅读量90 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58507222/article/details/133963240
版权

前言

顺序栈前言：
        栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

提示：以下是本篇文章正文内容，下面案例可供参考

一、顺序栈的定义

        栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来），也就是后进先出（LIFO）或者先进后出。

二、 顺序栈的运算

顺序栈的运算包括入栈（push）、出栈（pop）、取栈顶元素（top）以及判断栈是否为空（isEmpty）。

入栈操作：在顺序栈的末尾添加一个元素。如果栈为空，将新元素作为栈顶元素；如果栈不为空，将新元素添加到栈的末尾，并将栈顶指针下移一位。可以使用数组来实现顺序栈，通过数组的尾部进行元素的插入。
出栈操作：删除顺序栈的最后一个元素。如果栈为空，不能进行出栈操作；如果栈只有一个元素，删除该元素后栈为空。将栈顶指针上移一位，并返回被删除的元素。
取栈顶元素：返回顺序栈的最后一个元素，并不删除。如果栈为空，返回特定值（如-1）表示取不到。
判断栈是否为空：检查顺序栈是否为空，如果为空返回true，否则返回false。

这些基本运算可以在O(1)时间复杂度内完成。

三、 顺序栈的实现

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);
}

四、完整代码(Demo)

#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[]=(
    "/n"   
    );

五、运行结果截图

总结

顺序栈是一种基于数组实现的后进先出（LIFO）数据结构，具有记忆作用。其主要运算包括入栈（push）、出栈（pop）、取栈顶元素（top）以及判断栈是否为空（isEmpty）。在顺序栈中，元素按照后进先出的原则存储，新元素总是被添加到栈的末尾，而删除操作则总是删除栈顶的元素。由于顺序栈使用数组来存储元素，因此其空间利用率较高，且支持随机访问。然而，由于数组的灵活性较低，顺序栈在插入和删除操作时可能需要移动大量的元素，因此其时间复杂度可能会较高。此外，顺序栈还存在栈溢出的问题，即在某些情况下可能会超出数组的容量限制。为了解决这个问题，可以采取一些措施，如使用动态数组或链表来实现栈，以避免数组的容量限制。

顺序栈基本操作
04-14
顺序栈基本操作 顺序栈实现 顺序栈
8583 顺序栈的基本操作.zip_8583顺序栈_数据结构
09-21
在“8583 顺序栈的基本操作.txt”这个文本文件中，可能会详细讲解这些操作的实现步骤、示例代码以及可能遇到的问题和解决方法。通过阅读和理解这份文档，你可以进一步提升在数据结构和8583协议上的知识，这对于从事...
顺序栈代码和讲解
09-27
顺序栈代码和讲解,内容详细全面,通俗易懂,通过测试,代码可以直接使用,方便大家学习.
数组顺序栈.rar
07-09
在这个"数组顺序栈.rar"的压缩包中，"数组顺序栈.txt"很可能是关于数组顺序栈的详细讲解，包括其原理、操作和示例代码。"下载说明.txt"可能是关于如何使用或解压文件的指南，而"A5下载- 更全的站长资源平台.url"则是...
实验3 顺序栈.zip
02-03
这个压缩包包含的文件主要讲解了顺序栈这一数据结构及其在C语言中的实现。顺序栈是栈数据结构的一种，它通过数组来存储元素，操作方便且效率较高。 顺序栈的基本概念： 顺序栈是一种特殊的线性表，它具有“后进先出...
二叉树遍历/算法&数据结构
2403_86942375的博客
11-10 666
其实很简单，根据遍历的顺序摆放遍历顺序和添加元素的顺序，(root.left, result)代表左子树，(root.right, result)代表右子树，(root.val)代表中节点。其实很简单，参数就是要目前遍历节点在哪，返回值也同理，终止条件就是指遍历到null的时候回溯，逻辑不要想复杂，根据顺序移动上述上个递归函数即可。前序（要理解遍历的核心，先把中节点塞入，然后根据栈去模拟，先加入右节点然后是左节点，移动到左节点继续加入）后序（就是前序遍历的左右调换顺序，然后再倒叙结果数组）
【初阶数据结构篇】二叉树OJ题
braveact的博客
11-10 448
根节点与左右孩子的数值进行比较，如果相等依次递归左右子树，如果为空，或者两者对应的值相等，则返回true。🚀 分享给更多人：如果你觉得这篇文章对你有帮助，欢迎分享给更多对C++感兴趣的朋友，让我们一起进步！可以将该二叉树看成两个独立的二叉树，分别将“两个二叉树”的根节点传入，判断该是否为相同的二叉树。将两个数的根节点的值依次比较，依次递归两根节点的左子树，若根节点为空，直接返回。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。期待你的三连，你的支持就是我创作的动力！
开放寻址法、链式哈希数据结构详细解读
m0_61840987的博客
11-06 941
开放寻址法在低负载因子时效率较高，而链式哈希在高负载因子下表现更稳定。
【数据结构】B树
藓类少女的博客
11-06 887
B树通常定义为一棵平衡的多路搜索树，并用一个整数 m 表示其阶数，即每个节点最多有 m 个子节点。每个节点最多包含 m - 1 个关键字和 m 个子节点。每个非根节点至少包含 ⌈m/2⌉−1 个关键字和 ⌈m/2⌉ 个子节点。根节点至少包含 1 个关键字，特殊情况除外（当树为空时，根节点没有关键字）。所有叶子节点都在同一层，即 B 树的高度是均匀的。每个节点的关键字从小到大排序，并且遵循左小右大的原则。每个关键字 k 的左子树的所有关键字都小于 k，右子树的所有关键字都大于 k。
希尔排序算法
a921876874的博客
11-06 966
希尔排序算法
python中常见的8种数据结构之一数组的应用
2301_81121233的博客
11-10 221
可能的类型码包括`b`（有符号整数）、`B`（无符号整数）、`u`（Unicode字符）、`h`（有符号短整数）、`H`（无符号短整数）、`i`（有符号整数）、`I`（无符号整数）、`l`（有符号长整数）、`L`（无符号长整数）、`f`（浮点数）、`d`（双精度浮点数）等。数组和列表的主要区别在于数组中的元素必须是同一种类型，而列表中的元素可以是任何类型。可以通过索引访问数组中的元素，也可以使用切片操作来获取数组的子集。3.音频处理：音频数据通常也以数组的形式存储，数组可以用来处理音频的采样值。
【01课_初识算法与数据结构】
weixin_42333261的博客
11-10 637
算法，个人理解就是计算一段逻辑，最简化，最快速的方式、方法每个函数，就包含了一定的算法，执行一定的计算逻辑。
Java进阶嵌套循环：十.冒泡与选择算法排序
2301_77163982的博客
11-06 271
使用冒泡与选择算法实现数组的排序
数据结构中数据有序性/ 单调性 ——二分查找
最新发布
weixin_64842400的博客
11-10 439
最后返回的时候，返回left / right+ 1都可，因为最后的情况一定是 left == right ，然后mid =left =right，然后right = mid -1 = left -1；如果left == right ，我们始终明确一点：【L，R】中的数字是不确定的，也就是nums[left]==nums[right] 这一个数字，我们还没验呢！给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。请你找出给定目标值在数组中的开始位置和结束位置。
python中常见的8种数据结构之一列表
2301_81121233的博客
11-10 632
示例：```del my_list[2] # 删除第三个元素``` 或者 ```my_list.remove(3) # 删除元素3```示例：```my_list = []``` 或者 ```my_list = [1, 2, 3]```示例：```print(my_list[1:3]) # 输出从第二个元素到第三个元素的切片```示例：```print(len(my_list)) # 输出列表的长度```示例：```print(my_list[0]) # 输出第一个元素```
【数据结构】交换排序——冒泡排序 和 快速排序
2302_79968411的博客
11-10 520
其实经过学习，快速排序其实在发明之初并不是最快的但是经过多轮改进快速排序已经被存在了 c 语言库中就是qsort这是 c 语言库中的快排我讲的那两个优化比较简单所以这里挖个坑对于快速排序对重复数据较多的数据排序方法三路划分以及防止栈溢出，非递归解决方法栈模拟递归这些我后面会陆续发出来的因为要是一起就篇幅太大了。
95.【C语言】数据结构之双向链表的头插,头删,查找,中间插入,中间删除和销毁函数
2401_85828611的博客
11-10 435
1.双向链表的头插 　 方法一 　 方法二 2.双向链表的头删 3.双向链表的销毁 4.双向链表的某个节点的数据查找 5.双向链表的中间插入 5.双向链表的中间删除 6.对比顺序表和链表
【C++】算法与数据结构--最长连续串
weixin_40293999的博客
11-10 69
而s2 仅仅会跑 1—>5 2–> 1 发现在集合里就jump了 同理3–>2, 4–>3 …这里面用两个方法解决了这个问题，但是第一个方法不太好，时间复杂度高，在真正跑力扣的时候有一个用例会超时，这是因为。的时候， s1 会 1—>5, 2–>5, 3–>5, 4–>5, 5, 这样子都跑。当遇到【1，2，3，4，5，7，8，9】
【数据结构】【线性表】单链表2—单链表的插入(附C语言源码)
weixin_58498967的博客
11-10 155
我们也可以通过另一种方法，不找前驱结点，不改变前驱结点的next，而将新结点插入到指定结点的后面，再将指定结点与插入的新结点的所有数据交换，玩一手偷天换日。按位序插入，则在链表的第i位插入一个结点，由于链表是物理结构为链式存储的线性表，其存储内存不连续，依靠结点中元素数据中的指针数据指向下一结点，因此要插入一个结点到第i个位置，只需要找到第i-1个元素，将其指针数据给插入结点的指针数据，并将自己的指针数据更新为指向i即可。将指定节点的原有的指针数据给插入结点，并更新现在的指针数据指向插入结点。
C语言实现：顺序栈与链式栈的代码讲解
该资源是一个关于C语言实现数据结构中栈的PPT，主要涵盖了顺序栈和链栈的实现。内容包括实验目标、原理、基本操作的实现以及测试。 在数据结构中，栈是一种特殊的线性表，具有后进先出（LIFO）的特性。在C语言中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值