【数据结构】栈及栈的实现

于 2023-08-20 18:31:36 发布
阅读量214 收藏 14
点赞数 17
分类专栏： 《数据结构&算法》 文章标签： 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hz_eng/article/details/132378481
版权

目录

一、栈

      1. 栈的概念及结构

  2. 栈的表示和实现

       2.1  栈的顺序存储表示的实现

栈的初始化    

入栈操作

出栈操作

获取栈顶元素

获取栈中有效元素的个数   

 栈的判空操作  

栈的销毁

代码汇总

2.2  栈的链式存储表示的实现

初始化为空栈

入栈

出栈

栈的长度

获取栈顶元素

判断栈空

清空栈为空栈

栈的遍历

代码汇总

一、栈

      1. 栈的概念及结构

    栈(stack)：是限定仅在表尾进行插入或删除操作的一种特殊的线性表。它的特殊之处就在于限制了线性表的插入和删除位置。把允许插入和删除的一端称为栈顶(top)，另一端称为栈底；不含任何元素的栈称为空栈。栈又称为后进先出 (Last In First Out) 的线性表，简称LIFO结构。

压栈：栈的插入操作叫做进栈/压栈/入栈。入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。
 

  2. 栈的表示和实现

            和线性表类似，栈也有两种存储表示方法，即顺序栈(栈的顺序存储结构)和链栈(栈的链式         存储结构)。这两种结构都可以实现，但相对而言数组结构更优一些。

       2.1  栈的顺序存储表示的实现

               顺序栈(栈的顺序存储结构)：是利用一组地址连续的存储单元依次存放自栈底到栈顶的数          据元素，同时附设指针 top 指示栈顶元素在顺序栈中的位置。（以 top=0或top=-1来表示空          栈）。此处顺序栈的实现以 top=0来实现。 

 

      对于栈的实现，此处分模块进行

        ①Stack.h    //创建头文件，这部分进行函数的声明及类型的定义

        ②Stack.c    //源文件，主要是函数的实现

   下面是所有要实现的函数的声明、类型的定义：都在头文件Stack.h中进行

//所需要包含的头文件
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

//栈的结构定义
typedef int STDataType; //STDataType类型根据实际情况而定，这里假设为int
typedef struct Stack
{
    STDataType* a;
    int top;  //用于栈顶指针
    int capacity; //栈当前可使用的最大容量
}SqStack;

//函数的声明
//初始化栈
void SqStackInit(SqStack* ps);

//栈的销毁
void SqStackDestroy(SqStack* ps);

//入栈
void SqStackPush(SqStack* ps, STDataType x);

//出栈
void SqStackPop(SqStack* ps);

//获取栈顶元素
STDataType SqStackTop(SqStack* ps);

//获取栈中有效元素个数
int SqStackSize(SqStack* ps);

//判断栈是否为空
bool SqStackEmpty(SqStack* ps);

   

以下函数的实现均在 Stack.c中进行。

栈的初始化    
//初始化栈
void SqStackInit(SqStack* ps)
{
    assert(ps); //以防ps为空指针
    ps->a = NULL;
    ps->top = 0;  //在栈底的位置
    ps->capacity = 0; //当前最大容量初始化为0
}
入栈操作
//入栈
void SqStackPush(SqStack* ps, STDataType x)
{
    assert(ps);
    //栈满动态扩容
    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//容量扩容
        //动态开辟空间，成功则返回空间首地址
        STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
        //判断空间申请是否成功，失败退出
        if (tmp == NULL)
        {
            perror("realloc fail");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
    ps->a[ps->top] = x; //元素入栈
    ps->top++; //栈顶指针加一
}

      上面代码个别语句的解释如下:

      上述代码中扩容的那条语句首先需要判断当前最大容量是否为0，若为0直接扩容多大，否则扩容当前容量的2倍； 然后就是动态开辟空间此处用的是 realloc 而没有用 malloc 原因是因为此处用realloc可以避免后面由于开辟的空间不足还要使用realloc进行动态扩容。这里由于一开始数组中元素为零，此时realloc和malloc的作用相同的，因此就避免先使用malloc,在使用realloc扩容的问题 .

出栈操作
//出栈
void SqStackPop(SqStack* ps)
{
    assert(ps);
    assert(ps->top > 0); //避免为空，assert更为暴力，也可if判断
    --ps->top; //栈顶指针减一
}

获取栈顶元素
//获取栈顶元素
STDataType SqStackTop(SqStack* ps)
{
    assert(ps);
    assert(ps->top > 0); 
    return ps->a[ps->top - 1]; //将栈顶元素返回
}

    由于top指向栈底时的值为0，即top=0；top的值总比数组元素下标多一，因此，top-1指向栈顶元素

获取栈中有效元素的个数   
//获取栈中有效元素个数
int SqStackSize(SqStack* ps)
{
    assert(ps);
    return ps->top; //返回当前元素的个数
}

       

 栈的判空操作  
//判断栈是否为空
bool SqStackEmpty(SqStack* ps)
{
    assert(ps);
    return ps->top == 0;
}
栈的销毁
//栈的销毁
void SqStackDestroy(SqStack* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}

 

代码汇总
//Stack.h

//所需要包含的头文件
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

//栈的结构定义
typedef int STDataType; //STDataType类型根据实际情况而定，这里假设为int
typedef struct Stack
{
    STDataType* a;
    int top;  //用于栈顶指针
    int capacity; //栈当前可使用的最大容量
}SqStack;

//函数的声明
void SqStackInit(SqStack* ps);

void SqStackDestroy(SqStack* ps);

void SqStackPush(SqStack* ps, STDataType x);

void SqStackPop(SqStack* ps);

STDataType SqStackTop(SqStack* ps);

int SqStackSize(SqStack* ps);

bool SqStackEmpty(SqStack* ps);



//Stack.c

//初始化栈
void SqStackInit(SqStack* ps)
{
    assert(ps); 
    ps->a = NULL;
    ps->top = 0;  
    ps->capacity = 0; 
}


//入栈
void SqStackPush(SqStack* ps, STDataType x)
{
    assert(ps);

    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
        if (tmp == NULL)
        {
            perror("realloc fail");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }
    ps->a[ps->top] = x; 
    ps->top++; 
}


//出栈
void SqStackPop(SqStack* ps)
{
    assert(ps);
    assert(ps->top > 0); 
    --ps->top; 
}


//获取栈顶元素
STDataType SqStackTop(SqStack* ps)
{
    assert(ps);
    assert(ps->top > 0); 
    return ps->a[ps->top - 1]; 
}


//获取栈中有效元素个数
int SqStackSize(SqStack* ps)
{
    assert(ps);
    return ps->top; 
}


//判断栈是否为空
bool SqStackEmpty(SqStack* ps)
{
    assert(ps);
    return ps->top == 0;
}


//栈的销毁
void SqStackDestroy(SqStack* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}

2.2  栈的链式存储表示的实现

        栈的链式存储结构，简称为链栈，它是运算受限的单链表，即插入和删除操作仅限制在表头（对于链式栈对应的是栈顶，即把栈顶放在单链表的头部）位置进行。既然把栈顶放在单链表的头部，那单链表中比常用的头结点也就失去了意义，通常对于链栈来说，是不需要头结点的；基本不存在栈满的情况。

        对于空栈来说，链表原定义是头指针指向空，那么链栈的空就是 top=NULL.

     

 

         对于链栈的实现与顺序栈一样分两个模块。

         函数的声明、类型的定义：  LinkStack.h       

#include <stdio.h>
#include <stdlib.h>   
#include <stdbool.h>  
#include <assert.h>


typedef int SElemType; // SElemType类型根据实际情况而定，这里假设为int 
/* 链栈结构 */
typedef struct StackNode
{
    SElemType data;
    struct StackNode* next;
}StackNode;

typedef struct
{
    StackNode* top;
    int count;
}LinkStack;


//  构造一个空栈S 
void InitStack(LinkStack* S);

//遍历并输出栈中元素
void StackTraverse(LinkStack* S);

// 把S置为空栈 
void ClearStack(LinkStack* S);

// 若栈S为空栈，则返回TRUE，否则返回FALSE 
bool StackEmpty(LinkStack* S);

// 返回S的元素个数，即栈的长度 
int StackLength(LinkStack* S);

// 若栈不空,返回栈顶元素
SElemType GetTop(LinkStack* S);

// 插入元素e为新的栈顶元素 
void StackPush(LinkStack* S, SElemType e)；

// 出栈，若栈不空，则删除S的栈顶元素，并返回0；否则返回-1 
int StackPop(LinkStack* S)；

  函数的实现：LinkStack.c 

初始化为空栈
void InitStack(LinkStack* S)
{
    S->top = (StackNode*)malloc(sizeof(StackNode));
    if (S->top == NULL)
    {
        perror("malloc fail");
    }
    S->top = NULL;
    S->count = 0;
}
入栈
// 插入元素e为新的栈顶元素
void StackPush(LinkStack* S, SElemType e)
{
    StackNode* s = (StackNode*)malloc(sizeof(StackNode));
    if (s == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    s->data = e;
    s->next = S->top;	// 把当前的栈顶元素赋值给新结点的直接后继
    S->top = s;         // 将新的结点s赋值给栈顶指针
    S->count++;
}
出栈
// 出栈，若栈不空，则删除S的栈顶元素，并返回0；否则返回-1 
int StackPop(LinkStack* S)
{
    StackNode* p;
    if (StackEmpty(S))
        return -1;
    p = S->top;	           // 将栈顶结点赋值给p
    S->top = S->top->next; // 使得栈顶指针下移一位，指向后一结点
    free(p);               // 释放结点p 
    S->count--;
    return 0;
}
栈的长度
// 返回S的元素个数，即栈的长度 
int StackLength(LinkStack* S)
{
    assert(S);
    return S->count;
}
获取栈顶元素
// 若栈不空，返回栈顶元素 
SElemType GetTop(LinkStack* S)
{
    assert(S->top);
    return S->top->data;
}
判断栈空
// 若栈S为空栈，则返回TRUE，否则返回FALSE 
bool StackEmpty(LinkStack* S)
{
    if (S->count == 0)
        return true;
    else
        return false;
}
清空栈为空栈
// 把S置为空栈 
void ClearStack(LinkStack* S)
{
    StackNode* p, *q;
    p = S->top;
    while (p)
    {
        q = p;
        p = p->next;
        free(q);
    }
    S->count = 0;
}
栈的遍历
//遍历并输出栈中元素
void StackTraverse(LinkStack* S)
{
    StackNode* p;
    p = S->top;
    while (p)
    {
        printf("%d ->", p->data);
        p = p->next;
    }
    printf("\n");
}
代码汇总
//LinkStack.h

#include <stdio.h>
#include <stdlib.h>   
#include <stdbool.h>  
#include <assert.h>


typedef int SElemType; // SElemType类型根据实际情况而定，这里假设为int 
/* 链栈结构 */
typedef struct StackNode
{
    SElemType data;
    struct StackNode* next;
}StackNode;

typedef struct
{
    StackNode* top;
    int count;
}LinkStack;

 
void InitStack(LinkStack* S);

void StackTraverse(LinkStack* S);

void ClearStack(LinkStack* S);
 
bool StackEmpty(LinkStack* S);

int StackLength(LinkStack* S);

SElemType GetTop(LinkStack* S);
 
void StackPush(LinkStack* S, SElemType e)；
 
int StackPop(LinkStack* S)；


//

void InitStack(LinkStack* S)
{
    S->top = (StackNode*)malloc(sizeof(StackNode));
    if (S->top == NULL)
    {
        perror("malloc fail");
    }
    S->top = NULL;
    S->count = 0;
}


void StackPush(LinkStack* S, SElemType e)
{
    StackNode* s = (StackNode*)malloc(sizeof(StackNode));
    if (s == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    s->data = e;
    s->next = S->top;	// 把当前的栈顶元素赋值给新结点的直接后继
    S->top = s;         // 将新的结点s赋值给栈顶指针
    S->count++;
}

 
int StackPop(LinkStack* S)
{
    StackNode* p;
    if (StackEmpty(S))
        return -1;
    p = S->top;	           // 将栈顶结点赋值给p
    S->top = S->top->next; // 使得栈顶指针下移一位，指向后一结点
    free(p);               // 释放结点p 
    S->count--;
    return 0;
}


int StackLength(LinkStack* S)
{
    assert(S);
    return S->count;
}


SElemType GetTop(LinkStack* S)
{
    assert(S->top);
    return S->top->data;
}

 
bool StackEmpty(LinkStack* S)
{
    if (S->count == 0)
        return true;
    else
        return false;
}


void ClearStack(LinkStack* S)
{
    StackNode* p, *q;
    p = S->top;
    while (p)
    {
        q = p;
        p = p->next;
        free(q);
    }
    S->count = 0;
}


void StackTraverse(LinkStack* S)
{
    StackNode* p;
    p = S->top;
    while (p)
    {
        printf("%d ->", p->data);
        p = p->next;
    }
    printf("\n");
}

HZ_ENG
关注
  • 17
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
栈的动态顺序存储表示
理工科的杜小甫的博客
06-23 2335
采用动态一维数组来存储栈。所谓动态，指的是栈的大小可以根据需要增加。 ◆ 用bottom表示栈底指针，栈底固定不变的；栈顶则随着进栈和退栈操作而变化。用top(称为栈顶指针)指示当前栈顶位置。 ◆ 用top=bottom作为栈空的标记，每次top指向栈顶数组中的下一个存储位置。 ◆ 结点进栈：首先将数据元素保存到栈顶(top所指的当前位置)，然后执行top加1，使top指向栈顶的下一个存储位置
栈的基础概念和顺序存储表示
最新发布
2302_80454737的博客
04-12 159
栈的基础概念和顺序存储表示
栈的表示和操作的实现
weixin_46072203的博客
04-03 563
栈的定义： 仅限在表尾进行插入和删除操作的线性表 注意事项： 设栈S = （a1,a2,a3,a4,a5），则a1为栈底，a2为栈顶； 操作原则：后进先出（Last In First Out，LIFO） 栈的基本操作：(&为引用类型) InitStack(&S) 构建一个空栈S DestroyStack(&S) 销毁栈 ClearStack(&S) 清空栈 StackEmpty(S) 若栈为空返回true，否则返回false StackLength(S).
3.1.2栈的存储表示和实现
Zzc_IT_log的博客
08-26 292
栈的顺序存储结构称为顺序栈。由于栈是受运算限制的线性表，因此线性表的存储结构对栈也适用。顺序栈也是用数组实现的。因为栈底的位置是不变的，故可以将栈底位置设置在数组的最低端（即下标为0）；栈顶则是通过进栈和退栈操作而变化的。下面我们用Java和c来描述顺序栈的数据结构。 Java语言描述顺序栈的基本运算实现 public class SeqStack { int top = -1; //栈顶 int[] data = new int[20]; // 栈元素个数 //判断栈是否为空
堆栈的两种表示方法-数据结构学习笔记2.2
凤凰涅磐
03-27 1119
顺序存储表示#include #include typedef int Elem; #define MAX 200 const Elem ERROR=-1; typedef  struct{ Elem data[MAX]; int top; }*S,SS; S createStack(){ S s=(S)malloc(sizeof(SS)); s->top=-1; return s; }
java数据结构之java实现栈
09-04
Java 数据结构之 Java 实现栈 Java 数据结构实现栈是 Java 编程语言中的一种基础数据结构。栈是一种抽象数据类型，遵循 FILO（First In Last Out，先进后出）原则，即最后入栈的元素最先出栈。栈的实现有多种方式，...
C++实现数据结构-栈
11-10
C++实现数据结构-栈
数据结构-栈的C语言实现
01-20
数据结构-栈的C语言实现，随手笔记
C语言 数据结构中栈的实现代码
09-01
数据结构中的栈是一种非常基础且重要的抽象数据类型，它的特点是具有后进先出（LIFO，Last In First Out）的特性。栈的操作主要包括入栈（Push）和出栈（Pop）。在C语言中，我们可以使用两种方式来实现栈：静态栈...
数据结构之栈的定义及实现
09-29
在这个主题中，“数据结构之栈的定义及实现”将深入探讨栈的基本概念、操作以及在编程中的具体实现。 栈的定义： 栈是一种线性数据结构，它的特点是元素只能在栈的一端进行插入和删除操作，这一端被称为栈顶。新...
C++ 一图搞懂“从栈底往栈顶压、从栈顶往栈底压”两种情况
热门推荐
Spr Chan的博客
03-16 1万+
设栈的存储空间为S(1:m)，表示栈内存储m个元素   通常情况，栈都是从栈底往栈顶压，初始状态栈顶指针top=0（栈空）。当top=m+1，栈满；当top=23，栈内有23个元素。   当从栈顶往栈底压时，初始状态栈顶指针top=m+1（栈空）。当top=0，栈满；当top=23，栈内有(m+1-23)个元素。 ...
栈的顺序存储表示
weixin_42480264的博客
07-31 3576
顺序栈，即栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置。通常的习惯做法以top=0表示空栈。一般来说，在初始化设空栈时不应限定栈的最大容量。一个较合理的做法：先为栈分配一个基本容量，然后在应用过程中，当栈的空间不足在进行扩展。空栈时的表示为S.top == S.base。 ///栈的顺序存储表示 #include &...
从栈的顶部开始存放元素 c语言,数据结构 栈的顺序存储结构
weixin_32494473的博客
05-18 648
栈是一种特殊的线性表，所以在前面讨论的线性表的各种存储结构都可以作为栈的存储结构，因此，栈也有两种存储表示方法：顺序存储和链式存储。栈的顺序结构简称顺序栈，是利用一组地址连续的存储单元一次存放紫栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置。用一维数组表示栈的顺序存储结构，一般以top=0表示空栈，由于C语言中数组的小标约定从0开始，因此用C做描述语言时，这样设定会带来很大不...
栈的表示方法和实现
weixin_45875703的博客
11-22 2461
在数据结构的学习中，我们都知道栈是一种非常重要的线性结构。从数据结构角度看，栈也是线性表，其特殊性在于基本操作是线性表操作的子集，是操作受限的线性表，因此，可称为限定性的数据结构。从数据类型看，它又是和线性表不同的一种抽象数据类型。 栈的定义 栈是限定仅在表尾进行插入或删除操作的线性表。对于栈来说，表尾端称为栈顶，表头端为栈底，不含有任何元素的空表称为空栈。 数据结构中的栈跟我们生活中的箱子类似，...
栈和队列知识点总结
Akalaka的博客
03-08 7571
栈和队列知识点总结一、栈-入栈与出栈二、循环队列-入队与出队三、栈的存储空间为S(1:m)，初始状态为top=m+1四、带链的栈和带链的队列五、线性链表-存储空间不连续六、线性结构与非线性结构-判断准则 一、栈-入栈与出栈 栈的存储空间为S(1:50)，初始状态为top=51，即栈的初始状态为空。当第一个元素进栈后，top=50，第二个元素进栈后，top=49,第三个元素进栈后，top=48,以此类推，若第三个元素出栈后，top=48，第二个元素出栈后，top=50。即每进栈一个元素，top－1;每出栈一个
数据结构之栈（知识整理）
bxz0729的博客
10-24 3769
1.栈：来自线性表数据结构，都是“操作受限、存储受限”的线性表 2.栈方式： 硬堆栈：利用寄存器实现，堆栈容量有限，但速度快 软堆栈：在内存中实现，堆栈容量可以达到很大，速度慢 3.栈（stack）：是限制在表的一端进行插入和删除操作的线性表，又称为先入后出线性表 栈顶（top）：允许进行插入、删除操作的一端，称为表尾。用栈顶指针（top）来指示栈顶元素 栈底（bottom）：是固定端，又称表头 空栈：当表中没有元素时称为空栈 4.栈的顺序存储： 用一维数组来存储栈...
数据结构——栈的顺序存储表示
kuronekonano的博客
11-20 1140
数据结构作业之五，留作模板保存#include<string.h> #include<ctype.h> #include<malloc.h> // malloc()等 #include<limits.h> // INT_MAX等 #include<stdio.h> // EOF(=^Z或F6),NULL #include<stdlib.h> // atoi() #include<io.h> // e
数据结构浅析：栈与队列的运用及实现
"本资源主要介绍了算法思想中的数据结构——栈和队列，特别是栈的使用和实现。通过一个计算表达式的例子展示了栈在解决实际问题中的应用，并讲解了栈的顺序存储结构和链式存储结构，以及相关操作如进栈、退栈的基本...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值