数据结构——顺序栈

已于 2022-10-28 22:25:02 修改
阅读量921 收藏 1
点赞数 1
分类专栏： 学习笔记 文章标签： 指针 数据结构
于 2022-10-28 22:22:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47168849/article/details/127580303
版权

顺序栈

栈包含顺序栈和链栈，对应两种存储结构：顺序存储和链式存储，但它们同属于一个逻辑结构，即线性结构。

文章目录

一、栈的定义

栈，从数据结构的方向来看，它属于线性表的一种，它的操作是线性表的操作的阉割，栈中存储的数据遵循：先进后出、后进先出的原则。

名词解释

  1. 栈顶：表示下一个要存储数据的地址。
  2. 栈底：表示第一次存储数据的地址。
  3. 空栈：表示没有存储数据的栈。
  4. 入栈：也称压栈，就是将数据放入到栈顶的过程。
  5. 出栈：就是将上一次存储的数据取出的过程。

栈的常用操作

SqStack *build_stack(void);               //建立顺序栈
bool stack_is_empty(SqStack *S);          //判空
bool stack_is_full(SqStack *S);           //判满
int get_Length_Stack(SqStack *S);         //获取栈的实际长度
bool stack_push(SqStack *S, Stack_t val); //入栈
Stack_t stack_pop(SqStack *S);            //出栈
Stack_t stack_GetTop(SqStack *S);         //读栈顶
void Print_Stack(SqStack *S);             //遍历栈
bool Destroy_Stack(SqStack **S);          //销毁栈

二、栈的基本操作

采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素。本文只介绍顺序栈的操作。

定义顺序栈
#define Stack_Init_Size 10 // 初始化栈的最大长度
#define StackIncrement 10  // 若栈最大空间不够时，需要增加的长度
typedef int Stack_t;
typedef struct
{
    Stack_t *base;  // 栈底指针
    Stack_t *top;   // 栈顶指针
    int stack_size; // 栈的最大长度
} SqStack;
创建顺序栈

建立时用malloc在堆区申请了两个空间，一个用于存储顺序栈的结构体，一个用于存放要压栈的数据，并对栈顶和栈底进行了初始化。

SqStack *build_stack(void) //建立顺序栈
{
    SqStack *S = (SqStack *)malloc(sizeof(SqStack));
    if (S == NULL)
        return NULL;
    S->base = (Stack_t *)malloc(Stack_Init_Size * sizeof(Stack_t));
    if (S->base == NULL)
        return NULL;
    S->top = S->base;
    S->stack_size = Stack_Init_Size;
    return S;
}
判空判满

判断顺序栈是否为空，可以直接判断栈顶和栈底是否相等，相等即为空。

判断其是否未满，就判断栈顶和栈底偏移能存储的最大数量的Stack_t类型是否相等即可。

bool stack_is_empty(SqStack *S) //判空
{
    return S->base == S->top;
}
bool stack_is_full(SqStack *S) //判满
{
    return S->top == S->base + S->stack_size;
}
获取实际长度

用栈顶的指针变量减去栈底的指针变量就是中间存储的数量。

int get_Length_Stack(SqStack *S) //获取栈的实际长度
{
    if (S == NULL)
        return -1;
    return S->top - S->base;
}
入栈操作（重点）

在入栈前需要判断当前栈是否装满，如果装满就要对其扩容，可以使用realloc函数重新开辟一个更大的空间，此时也需要改变栈顶的指向，因为有可能栈底已经被realloc函数换到了另一个位置，改变栈顶后，直接在栈顶放入要存放的数据就完成了入栈操作。

在这之前我们需要了解realloc函数，大致是这样的：

extern void *realloc(void *mem_address, unsigned int newsize);

  1. 如果p指向的空间之后有足够的空间可以追加，则直接追加，返回的是p原来的起始地址。
  2. 如果p指向的空间之后没有足够的空间可以追加，则realloc函数会重新找一个新的内存区域，并且把原来内存空间的数据拷贝回来，释放旧的内存空间还给操作系统，最后返回新开辟的内存空间的起始地址。
bool stack_push(SqStack *S, Stack_t val) //入栈
{
    if (S == NULL)
        return false;
    if (stack_is_full(S)) //栈的空间满时，重新开辟空间
    {
        S->base = (Stack_t *)realloc(S->base, (S->stack_size + StackIncrement) * sizeof(Stack_t));
        if (S->base == NULL)
            return false;

        // 栈顶指针为栈底指针加上栈之前的最大长度
        S->top = S->base + S->stack_size;
        // 栈当前的最大长度等于栈之前的最大长度与增加的长度之和
        S->stack_size += StackIncrement;
    }
    // *S->top++ = val;
    *(S->top++) = val; // 先赋值，再将栈顶指针上移
    return true;
}
出栈操作

因为栈遵循先进后出、后进先出的原则，因此出栈时只能放出最近一次入栈的数据，即放出栈顶的上一个地址的里面的数据，就完成出栈操作。

Stack_t stack_pop(SqStack *S) //出栈
{
    if (S == NULL)
        return false;
    if (stack_is_empty(S))
        return false;
    return *(--S->top); //栈顶表示下一个数据要存放的地址、因此该地址中没有数据
}
读栈顶
Stack_t stack_GetTop(SqStack *S) //读栈顶
{
    if (S == NULL)
        return false;
    if (stack_is_empty(S))
        return false;
    return *(S->top - 1); //获取栈顶元素的但是不出栈
}
遍历栈

通过get_length获取栈的实际长度，然后用循环从栈顶遍历到栈底，逐一打印栈中存放的值。

void Print_Stack(SqStack *S) //遍历栈
{
    if (S == NULL)
        return;
    if (stack_is_empty(S))
    {
        puts("这个栈是空的！");
        return;
    }
    for (int i = 1; i < get_Length_Stack(S) + 1; i++)
    {
        printf("%-4d", *(S->top - i));
    }
    puts("\n");
}
销毁栈

销毁时要先free实际数据地址，再free顺序栈结构体的地址。其次要在销毁之后将原顺序栈赋值未NULL，就要采用二级指针。

bool Destroy_Stack(SqStack **S) //销毁栈
{
    if (*S == NULL)
        return true;
    free((*S)->base);
    free(*S);
    *S = NULL;
    return true;
}

三、完整代码

sqstack.c
/*
 * @Descripttion:
 * @version:
 * @Author: smile
 * @Date: 2022-10-28 16:28:22
 * @LastEditors: smile
 * @LastEditTime: 2022-10-28 18:19:10
 */
#include "sqstack.h"

SqStack *build_stack(void) //建立顺序栈
{
    SqStack *S = (SqStack *)malloc(sizeof(SqStack));
    if (S == NULL)
        return NULL;
    S->base = (Stack_t *)malloc(Stack_Init_Size * sizeof(Stack_t));
    if (S->base == NULL)
        return NULL;
    S->top = S->base;
    S->stack_size = Stack_Init_Size;
    return S;
}
bool stack_is_empty(SqStack *S) //判空
{
    return S->base == S->top;
}
bool stack_is_full(SqStack *S) //判满
{
    return S->top == S->base + S->stack_size;
}
int get_Length_Stack(SqStack *S) //获取栈的实际长度
{
    if (S == NULL)
        return -1;
    return S->top - S->base;
}
bool stack_push(SqStack *S, Stack_t val) //入栈
{
    if (S == NULL)
        return false;
    if (stack_is_full(S)) //栈的空间满时，重新开辟空间
    {
        S->base = (Stack_t *)realloc(S->base, (S->stack_size + StackIncrement) * sizeof(Stack_t));
        if (S->base == NULL)
            return false;

        // 栈顶指针为栈底指针加上栈之前的最大长度
        S->top = S->base + S->stack_size;
        // 栈当前的最大长度等于栈之前的最大长度与增加的长度之和
        S->stack_size += StackIncrement;
    }
    // *S->top++ = val;
    *(S->top++) = val; // 先赋值，再将栈顶指针上移
    return true;
}
Stack_t stack_pop(SqStack *S) //出栈
{
    if (S == NULL)
        return false;
    if (stack_is_empty(S))
        return false;
    return *(--S->top); //栈顶表示下一个数据要存放的地址、因此该地址中没有数据
}
Stack_t stack_GetTop(SqStack *S) //读栈顶
{
    if (S == NULL)
        return false;
    if (stack_is_empty(S))
        return false;
    return *(S->top - 1); //获取栈顶元素的但是不出栈
}
void Print_Stack(SqStack *S) //遍历栈
{
    if (S == NULL)
        return;
    if (stack_is_empty(S))
    {
        puts("这个栈是空的！");
        return;
    }
    for (int i = 1; i < get_Length_Stack(S) + 1; i++)
    {
        printf("%-4d", *(S->top - i));
    }
    puts("\n");
}
bool Destroy_Stack(SqStack **S) //销毁栈
{
    if (*S == NULL)
        return true;
    free((*S)->base);
    free(*S);
    *S = NULL;
    return true;
}
void run_stack(void) //运行顺序栈实例
{
    SqStack *S = build_stack();
    if (S == NULL)
        perror("建立失败\n");
    else
        puts("建立成功！");

    puts("\n-------------入栈9个:");
    for (int i = 1; i < 10; i++)
        stack_push(S, i);
    printf("此时栈的个数：%d,当前栈的最大长度是:%d\n", get_Length_Stack(S), S->stack_size);
    Print_Stack(S);

    puts("\n-------------再入栈9个:");
    for (int i = 1; i < 10; i++)
        stack_push(S, i * 100);
    printf("此时栈的个数：%d,当前栈的最大长度是:%d\n", get_Length_Stack(S), S->stack_size);
    Print_Stack(S);

    puts("\n-------------出栈18个:");
    for (int i = 1; i < 19; i++)
        printf("第%-2d次出了%-4d\n", i, stack_pop(S));
    printf("此时栈的个数：%d,当前栈的最大长度是:%d\n", get_Length_Stack(S), S->stack_size);

    int rand_t = rand() % 150 + 1;
    printf("\n-------------随机入栈%d个:\n", rand_t);
    for (int i = 0; i < rand_t; i++)
        stack_push(S, rand() % 1000);
    printf("此时栈的个数：%d,当前栈的最大长度是:%d\n", get_Length_Stack(S), S->stack_size);
    printf("此时栈顶是：%d\n", stack_GetTop(S));
    Print_Stack(S);

    puts("\n-------------销毁栈:");
    Destroy_Stack(&S) == 1 ? puts("销毁成功！") : puts("销毁失败！");
}
sqstack.h
/*
 * @Descripttion:
 * @version:
 * @Author: smile
 * @Date: 2022-10-28 16:28:30
 * @LastEditors: smile
 * @LastEditTime: 2022-10-28 21:08:34
 */
#ifndef _SQSTACK_H_
#define _SQSTACK_H_

#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <windows.h>

#define Stack_Init_Size 10 // 初始化栈的最大长度
#define StackIncrement 10  // 若栈最大空间不够时，需要增加的长度

//不定长型
typedef int Stack_t;
typedef struct
{
    Stack_t *base;  // 栈底指针
    Stack_t *top;   // 栈顶指针
    int stack_size; // 栈的最大长度
} SqStack;

SqStack *build_stack(void);               //建立顺序栈
bool stack_is_empty(SqStack *S);          //判空
bool stack_is_full(SqStack *S);           //判满
int get_Length_Stack(SqStack *S);         //获取栈的实际长度
bool stack_push(SqStack *S, Stack_t val); //入栈
Stack_t stack_pop(SqStack *S);            //出栈
Stack_t stack_GetTop(SqStack *S);         //读栈顶
void Print_Stack(SqStack *S);             //遍历栈
bool Destroy_Stack(SqStack **S);          //销毁栈

void run_stack(void); //运行顺序栈实例

#endif
main.c
#include "sqstack.h"

int main(void)
{
    srand((int)time(NULL));

    run_stack(); //运行顺序栈实例

    system("pause");
    return 0;
}
数据结构手把手教学——顺序栈
Sanjay_Wu的博客
01-28 744
文章不空谈理论，完全采用手把手教学，并有综合示例练习题，看完这篇，你绝对能掌握数据结构顺序栈。
数据结构——顺序栈详解
最新发布
weixin_51785373的博客
10-20 2213
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
数据结构-顺序栈
帅子的博客
04-18 228
#include <iostream> #include <string> using namespace std; #define STACKSIZE 10 typedef char DataType; typedef struct{ DataType data[STACKSIZE]; int top; }SeqStack; //置空栈 void initStack(SeqStack *s){ s->top=-1; } //判栈满 bool i.
数据结构 顺序栈
weixin_33734785的博客
03-26 307
做一个豁达而努力的自己。栈的定义：只能在表的一端（栈顶）进行插入和删除的线性表。逻辑结构：与线性表相同，仍为一一对应的关系。存储结构：用顺序栈和链栈存储均可，但以顺序栈更为常见。运算规则：只能在栈顶（top）进行运算，且访问节点时只能先进后出（FILO），或后进先出（LIFO）的原则。实现方式：关键是在写压栈和弹栈的函数具体的实现依顺序栈和链栈的不同而不同，基本的...
【数据结构】（三）顺序栈
weixin_50964793的博客
08-25 674
顺序栈
顺序栈结构
Gamedev
12-19 702
栈结构栈结构是一种线性结构，栈结构包括两类： 1. 顺序栈结构：即使用一组地址连续的内存单元依次保存栈中的数据。在程序中，可以定义一个指定大小的结构数组来作为栈，序号为0的元素就是栈底，再定义一个变量top保存栈顶的序号即可。 2. 链式栈结构：即使用链表形式保存栈中各元素的值。链表首部（head引用所指向元素）为栈顶，链表尾部（指向地址为null）为栈底。栈结构是按照“后进先出”的原则处理节点
数据结构——顺序栈的C语言实现
03-02
顺序栈是其中最基础且重要的数据结构之一，常被用于处理需要“后进先出”（Last In First Out, LIFO）逻辑的问题。本文将深入探讨顺序栈的概念，并通过C语言来实现它。 顺序栈是一种线性数据结构，它的元素在内存中...
数据结构——顺序栈的初始化、判断空、入栈、出栈、读取栈顶元素
Prescu的博客
06-15 1933
//顺序栈的相关操作 #include #include <stdio.h> #include <stdlib.h> #define Maxsize 10 typedef struct{ //顺序栈 int data[Maxsize]; int top; }SqStack; void InitStack(SqStack &S){//初始化栈 S.top=-1; } bool StackEmpty(SqStack S){//判断栈空 if(S.top==-1){ return
数据结构——顺序栈的表示和实现
JEYMING的博客
04-23 3537
/* 顺序栈的表示和实现 顺序栈：利用顺序存储结构，即利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素； 1.以top=0为栈空，即top=base为栈空； 2.以top=-1为栈空； 2019.04.15 */ #include&lt;iostream&gt; #include&lt;string.h&gt; #include&lt;stdlib...
数据结构——顺序栈的基本操作（C语言实现）
m0_46657980的博客
07-26 1577
1、定义 typedef struct SeqStack { ElemType *base;//栈空间 size_t capacity; int top;//栈顶指针 }SeqStack; 2、判空、判满 bool SeqStackIsEmpty(SeqStack *pst) { assert(pst != NULL); return pst->top == 0; } bool SeqStackIsFull(SeqStack *pst) { assert(pst != NULL)
顺序结构——顺序栈
盼盼的博客
08-21 431
今天说的是顺序栈。 而对于栈，我们最直观的了解就是它的先进后出原则，就和一群人走进的狭窄的死胡同是一样的，先进入的人被堵在里面，而后进入的人则可以先出去。 对于栈来说，当你的栈已满时，继续存入数据就会产生上溢 相对的，当栈为空栈时，继续出栈则会产生下溢 接下来，我们继续用一组代码，来看看顺序栈的一些操作 #include<stdio.h> #include<stdlib.h&gt...
顺序栈结构及操作
weiyouyin的专栏
06-25 904
#include #include #define STACK_INIT_SIZE 100#define STACK_CREMENT 10typedef struct  //定义顺序栈结构{ int *top,*base; int stacksize;}sqstack;sqstack_init(sqstack &q){ q.base=(int *)malloc(sizeof(int)*ST
4.数据结构：栈的顺序栈与链栈
weixin_52694360的博客
01-10 962
一.栈的介绍 当我们对线性表的操作做出某种限定的时候，即为受限制的线性表，限定的同，线性表也会不同，限定的线性表主要表示为，栈和队列； 栈，也称堆栈，是一种限定的操作的线性结构。日常生活中常见栈的实例，例如，我们夏天逛超市时,可能会忍不住想买一瓶冰饮料喝，饮料放在冰柜里,可是,冰柜中放在靠外的饮料往往并不冰，而深处我们够不着的地方,才是我们想要的。这种情况类似于线性结构中的栈,其特点就是，只能从冰柜门将饮料放人，先放进冰柜的在最里面，只能最后拿出来，除此之外，还有坐电梯,洗碗，一摞书,交作业先交的放在下面。
栈结构之顺序栈详解（C语言版）
qq_44075108的博客
10-24 1万+
本文对栈结构的顺序栈进行详解并使用C语言对顺序栈进行实现，文章的主要内容包括顺序栈的定义、顺序栈的结构以及顺序栈的常用操作
数据结构学习笔记：顺序栈和链栈（C语言）
热门推荐
她和她的猫的博客
09-24 2万+
栈是限定只能在表的一端进行插入或删除操作的线性表，允许插入、删除操作的一端是栈顶、另一端是栈顶，一般将插入和删除操作称为入栈和出栈，栈的顺序存储结构称为链栈，链式存储结构称为链栈。
栈的顺序存储结构（顺序栈）
一个搬运知识的笨小孩
07-27 4740
栈的顺序存储结构 1.顺序栈的存储结构 #define MAXSIZE 100 //顺序栈存储空间的初始分配 typedef struct{ SElemType *base; //栈底指针 SElemType *top; //栈顶指针 int stacksize; //栈可用的最大容量 }SqStack; 2.顺序栈的初始化 初始化就是为顺序栈动态分配一个预定义大小的数组空间 栈属于逻辑结构 数组为顺序存储结构（存储/物理结构：逻辑结构在计算机中的存储形式） 具体关系见本人关于数据结构第一章图
栈的顺序存储及实现（一）
重庆李四
12-23 9236
继续学习数据结构，今天我们来学习栈的相关知识。其实学习没有捷径，如果抱着一种吃快餐的态度进行学习，那是学不到东西，各种技术都是浅尝辄止，那注定学习是不会有太大的效果。不知道你们讨不讨厌 某某语言从入门到精通的这类书籍？我在想，有这么牛逼么，一本书直接都从入门到精通了，只不是吸引那些初学者的鳌头吧了。算法都是老前辈们留下来解决某一类问题非常行之有效的方法，不管什么时候都不会过时。虽然很多算法，在很多
栈Stack（一）--- 栈的顺序存储
kobe_jr的博客
03-30 3687
在介绍双向队列接口（Deque）时，就拿栈（Stack）与它相比较，可以看出栈是只能在一头进行操作的一种数据结构。就栈而言 ： 我们将进行插入和删除的一端叫做栈顶，相应地另一端也就是栈底。进栈与出栈： * 栈顶插入一个元素 --- 进栈   我们叫这个元素从栈顶被 “压入栈” -- push() * 栈顶删除一个元素 --- 出栈   我们叫这个元素从栈顶“弹出栈”   -- pop()原则   ...
堆栈的顺序存储
大力海棠的博客
03-28 5433
堆栈是一种特殊的线性表，是一种线性结构，只能对栈的顶端做操作，操作有入栈和出栈两种，就是插入和删除。堆栈一定要遵循先进后出（或叫后入先出）原则，就是最后一个进去的元素一定是第一个出来的。那么堆栈要怎么实现？第一个很简单的方法就是用一个一维数组，因为栈是一种按顺序存储的结构，所以可以用一维数组来存储栈的数据。因为栈有一个特点是后入先出，最后进入的元素最先出来，所以还要有一个数据来存储栈中最后一个元素...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值