栈 （Stack） 的定义和实现

最新推荐文章于 2023-10-12 20:19:51 发布
最新推荐文章于 2023-10-12 20:19:51 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 栈 线性表 单链表 线性栈 链式栈

栈的定义

栈是一种特殊的线性表。
栈仅能在线性表的一端进行操作：
栈顶(Top)：允许操作的一端
栈底(Bottom)：不允许操作的一端

性质：后进先出(LIFO) Last In First Out
这里写图片描述

栈的一些常用操作：
创建栈
销毁栈
清空栈
进栈
出栈
获取栈顶元素
获取栈的大小

栈的顺序存储实现

这里写图片描述

顺序栈的代码实现：
栈是一种特殊的线性表，因此顺序栈的实现需要借助于顺序表的代码，利用代码复用：

//顺序表 头文件 SeqList.h
#ifndef _SEQLIST_H_
#define _SEQLIST_H_

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);
void SeqList_Destroy(SeqList* list);
void SeqList_Clear(SeqList* list);
int SeqList_Length(SeqList* list);
int SeqList_Capacity(SeqList* list);
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
SeqListNode* SeqList_Get(SeqList* list, int pos);
SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif
//顺序表 源文件 SeqList.c
#include <stdio.h>
#include <malloc.h>
#include "SeqList.h"

typedef unsigned int TSeqListNode;

typedef struct _tag_SeqList
{
    int capacity;
    int length;
    TSeqListNode* node;
} TSeqList;

SeqList* SeqList_Create(int capacity) // O(1)
{
    TSeqList* ret = NULL;

    if( capacity >= 0 )
    {
        ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode) * capacity);
    }

    if( ret != NULL )
    {
        ret->capacity = capacity;
        ret->length = 0;
        ret->node = (TSeqListNode*)(ret + 1);
    }

    return ret;
}

void SeqList_Destroy(SeqList* list) // O(1)
{
    free(list);
}

void SeqList_Clear(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;

    if( sList != NULL )
    {
        sList->length = 0;
    }
}

int SeqList_Length(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    int ret = -1;

    if( sList != NULL )
    {
        ret = sList->length;
    }

    return ret;
}

int SeqList_Capacity(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    int ret = -1;

    if( sList != NULL )
    {
        ret = sList->capacity;
    }

    return ret;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n) 
{
    TSeqList* sList = (TSeqList*)list;
    int ret = (sList != NULL);
    int i = 0;

    ret = ret && (sList->length + 1 <= sList->capacity);
    ret = ret && (0 <= pos);

    if( ret )
    {
        if( pos >= sList->length )
        {
            pos = sList->length;
        }

        for(i=sList->length; i>pos; i--)
        {
            sList->node[i] = sList->node[i-1];
        }

        sList->node[i] = (TSeqListNode)node;

        sList->length++;
    }

    return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos) // O(1) 
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = NULL;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        ret = (SeqListNode*)(sList->node[pos]);
    }

    return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos) // O(n)
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = SeqList_Get(list, pos);
    int i = 0;

    if( ret != NULL )
    {
        for(i=pos+1; i<sList->length; i++)
        {
            sList->node[i-1] = sList->node[i];
        }

        sList->length--;
    }

    return ret;
}
//顺序栈 头文件 SeqStack.h
#ifndef _SEQSTACK_H_
#define _SEQSTACK_H_

typedef void SeqStack;

SeqStack* SeqStack_Create(int capacity);
void SeqStack_Destroy(SeqStack* stack);
void SeqStack_Clear(SeqStack* stack);
int SeqStack_Push(SeqStack* stack, void* item);
void* SeqStack_Pop(SeqStack* stack);
void* SeqStack_Top(SeqStack* stack);
int SeqStack_Size(SeqStack* stack);
int SeqStack_Capacity(SeqStack* stack);

#endif
//顺序栈 源文件 SeqStack.c
#include "SeqStack.h"
#include "SeqList.h"

SeqStack* SeqStack_Create(int capacity)
{
    return SeqList_Create(capacity);
}

void SeqStack_Destroy(SeqStack* stack)
{
    SeqList_Destroy(stack);
}

void SeqStack_Clear(SeqStack* stack)
{
    SeqList_Clear(stack);
}

int SeqStack_Push(SeqStack* stack, void* item)
{
    return SeqList_Insert(stack, item, SeqList_Length(stack));
}

void* SeqStack_Pop(SeqStack* stack)
{
    return SeqList_Delete(stack, SeqList_Length(stack) - 1);
}

void* SeqStack_Top(SeqStack* stack)
{
    return SeqList_Get(stack, SeqList_Length(stack) - 1);
}

int SeqStack_Size(SeqStack* stack)
{
    return SeqList_Length(stack);
}

int SeqStack_Capacity(SeqStack* stack)
{
    return SeqList_Capacity(stack);
}

栈的链式存储实现

这里写图片描述
同样，链式栈复用了单链表的代码：

//单链表 头文件 LinkList.h
#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
    LinkListNode* next;
};

LinkList* LinkList_Create();
void LinkList_Destroy(LinkList* list);
void LinkList_Clear(LinkList* list);
int LinkList_Length(LinkList* list);
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);
LinkListNode* LinkList_Get(LinkList* list, int pos);
LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif
//单链表 源文件 LinkList.c
#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"

typedef struct _tag_LinkList
{
    LinkListNode header;
    int length;
} TLinkList;

LinkList* LinkList_Create() // O(1)
{
    TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));

    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
    }

    return ret;
}

void LinkList_Destroy(LinkList* list) // O(1)
{
    free(list);
}

void LinkList_Clear(LinkList* list) // O(1)
{
    TLinkList* sList = (TLinkList*)list;

    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
    }
}

int LinkList_Length(LinkList* list) // O(1)
{
    TLinkList* sList = (TLinkList*)list;
    int ret = -1;

    if( sList != NULL )
    {
        ret = sList->length;
    }

    return ret;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos) // O(n)
{ 
    TLinkList* sList = (TLinkList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;

    if( ret )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }

        node->next = current->next;
        current->next = node;

        sList->length++;
    }

    return ret;
}

LinkListNode* LinkList_Get(LinkList* list, int pos) // O(n)
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }

        ret = current->next;
    }

    return ret;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos) // O(n)
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }

        ret = current->next;
        current->next = ret->next;

        sList->length--;
    }

    return ret;
}
//链式栈 头文件 LinkStack.h
#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

typedef void LinkStack;

LinkStack* LinkStack_Create();
void LinkStack_Destroy(LinkStack* stack);
void LinkStack_Clear(LinkStack* stack);
int LinkStack_Push(LinkStack* stack, void* item);
void* LinkStack_Pop(LinkStack* stack);
void* LinkStack_Top(LinkStack* stack);
int LinkStack_Size(LinkStack* stack);

#endif
//链式栈 源文件 LinkStack.c
#include <stdio.h>
#include <malloc.h>
#include "LinkStack.h"
#include "LinkList.h"

typedef struct _tag_LinkStackNode
{
    LinkListNode header;
    void* item;
} TLinkStackNode;

LinkStack* LinkStack_Create()
{
    return LinkList_Create();
}

//每个链表中的元素都是经过malloc分配的内存，所以在销毁的时候，要把每个元素
//弹出链式栈，然后free 
void LinkStack_Destroy(LinkStack* stack)
{
    LinkStack_Clear(stack);
    LinkList_Destroy(stack);
}

void LinkStack_Clear(LinkStack* stack)
{
    while( LinkStack_Size(stack) > 0 )
    {
        LinkStack_Pop(stack);
    }
}

int LinkStack_Push(LinkStack* stack, void* item)
{
    TLinkStackNode* node = (TLinkStackNode*)malloc(sizeof(TLinkStackNode));
    int ret = (node != NULL) && (item != NULL);

    if( ret )
    {
        node->item = item;

        ret  = LinkList_Insert(stack, (LinkListNode*)node, 0);
    }

    if( !ret )
    {
        free(node);
    }

    return ret;
}

void* LinkStack_Pop(LinkStack* stack)
{
    TLinkStackNode* node = (TLinkStackNode*)LinkList_Delete(stack, 0);
    void* ret = NULL;

    if( node != NULL )
    {
        ret = node->item;

        free(node);
    }

    return ret;
}

void* LinkStack_Top(LinkStack* stack)
{
    TLinkStackNode* node = (TLinkStackNode*)LinkList_Get(stack, 0);
    void* ret = NULL;

    if( node != NULL )
    {
        ret = node->item;
    }

    return ret;
}

int LinkStack_Size(LinkStack* stack)
{
    return LinkList_Length(stack);
}

小结

栈是一种特殊的线性表
栈只允许在线性表的一端进行操作
栈通常有两种实现方式：
顺序结构实现
链式结构实现

ZhY_Rening
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS栈stack类的实现与使用方法示例
10-17
通过上述解释的JS栈的实现和使用方法的知识点，可以了解到栈的基本操作、原理及如何在JavaScript中自定义一个栈类。这些知识点对于学习和应用栈结构非常有帮助，尤其是在处理需要“后进先出”操作的算法问题时。
（二）堆栈的定义和实现
kikibingo的专栏
10-18 2356
堆栈(Stack)可以认为是具有一定约束的线性表,$\color{red}{插入和删除操作都作用在一个称为栈顶(Top)的端点位置}$。 其实,我们日常生活中也可以看到堆栈的例子,比如，我们厨房中叠放的盘子,使用盘子(删除操作)时我们是从顶端拿走盘子,用完放回(插入操作)时也是放到顶端
【数据结构入门】栈（Stack）的实现（定义、销毁、入栈、出栈等） | 图解数据结构，超详细哦~
codewinter的博客
09-11 6282
文章目录（1）前言1）栈的概念2）进栈出栈的形式3）栈的存储结构（2）栈的实现（顺序栈）1）栈的定义2）栈的初始化3）栈的销毁4）入栈5）出栈6）检测栈是否为空7）获取栈中有效元素个数8）获取栈顶元素（3）测试栈的功能 数据结构系列文章： 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改） 【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~ 【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，
stack的理解
从改变自己开始
12-10 802
学习编程的时候，经常会看到stack这个词，它的中文名字叫做"栈"。 　　理解这个概念，对于理解程序的运行至关重要。容易混淆的是，这个词其实有三种含义，适用于不同的场合，必须加以区分。 　　含义一：数据结构 　　stack的第一种含义是一组数据的存放方式，特点为LIFO，即后进先出（Last in, first out）。 　　在这种数据结构中，数据像积木那样一层层堆起来，后面加入的数
栈（Stack)详细讲解
最新发布
weixin_71841320的博客
10-12 3087
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈 顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
栈 (stack)
m0_67711803的博客
09-15 897
栈（stack）又名堆栈，它是一种运算受限的线性表
JavaScript实现栈结构Stack过程详解
10-15
通过在Stack.prototype上定义push、pop、peek、isEmpty和size方法，我们可以实现栈的基本功能。以下是一个简单的实现： ```javascript function Stack() { this.items = []; } Stack.prototype.push = function...
Stack-栈实例
10-23
栈是一种特殊的线性数据结构，遵循“后进先出”（LIFO）的原则。在计算机科学中，栈常被用于解决各种问题，如...无论是静态栈还是链表栈，它们都提供了灵活的方式来管理和处理数据，使得算法的设计和实现更为便捷。
C++栈(stack)的模板类实现代码
08-30
在C++标准库中，`<stack>`提供了栈的模板类实现，但这里我们将讨论如何使用C++自定义模板类来实现一个简单的栈。 首先，栈的基本操作包括： 1. `push`：将元素添加到栈顶。 2. `pop`：移除栈顶元素并返回其值。 3. ...
C语言 栈的表示和实现详细介绍
09-01
在数组实现的顺序栈中，我们通常会定义一个结构体来表示栈，其中包括栈底`base`指针、栈顶`top`指针以及当前分配的存储空间大小`stacksize`。以下是一个简单的顺序栈结构体的定义： ```c typedef struct SqStack { ...
Stack的三种含义
趟过java，遇见web
08-11 221
其中，i和y的值是整数，内存占用空间是确定的，而且是局部变量，只用在Method1区块之内，不会用于区块之外。其他的区别还有，一般来说，每个线程分配一个stack，每个进程分配一个heap，也就是说，stack是线程独占的，heap是线程共用的。此外，stack创建的时候，大小是确定的，数据超过这个大小，就发生stack overflow错误，而heap的大小是不确定的，需要的话可以不断增加。程序运行的时候，总是先完成最上层的调用，然后将它的值返回到下一层调用，直至完成整个调用栈，返回最后的结果。
数据结构——栈Stack & 队列Queue(详解）
m0_74438843的博客
08-31 321
实现栈和队列的详细代码实现
数据结构-Stack的定义及其应用（python）
wwb623的博客
08-11 1641
Stack Stack作为线性数据结构中主要抽象数据类型之一，其特点就是“LIFO”（last in first out）即后进先出，这种特性我们一般称为反转次序。Stack可以解决许多问题，最为基础的就是括号匹配问题，十进制转换问题，中缀表达式转后缀表达式问题以及后缀表达式求值问题。以下便是这次数据结构栈类学习过程中的总结和笔记。 先是对栈类的定义，其功能一般有五个，即size（返回栈的大小），is_empty（判断栈是否为空），pop（弹出栈顶数据，并返回该数据），peek（返回栈顶数据），push（将
STL总结二
qq_42700637的博客
03-13 179
stack容器 简介 stack是堆栈容器，是一种“先进后出”的容器。 stack是简单地装饰deque容器而成为另外的一种容器。 栈不能遍历，不支持随机随机存取，只能通过top从栈顶获取和删除元素 stack的push()与pop()方法 stack.push(elem); //往栈头添加元素 stack.pop(); //从栈头移除第一个元素 stack对象...
c语言实现给栈添加索引,堆栈的简单实现之一：基本操作（C语言实现）
weixin_35369702的博客
05-22 391
堆栈(Stack)是一种操作受限的线性表，堆栈的插入和删除操作只能在一端进行。堆栈遵循着先进后出或者叫后进先出的原则。在堆栈中，允许插入和删除的一端叫着栈顶(Top)，另外一端叫着栈底(Bottom)。栈的基本操作包括：栈的初始化，栈的插入和删除，以及判断栈是否为空或者是否为满等。根据上面所说，来实现一个自己定义的堆栈的基本表示和实现。1、定义堆栈结构本文定义的堆栈采用链式存储结构，根据堆栈的特点...
数据结构-栈（Stack）-定义与基本操作
Burning Chrome
07-03 1225
数据结构-栈（Stack）-定义与基本操作一. 顺序栈（Sequential Stack）1. 定义2. 基本操作2.1 初始化2.2 进栈2.3 出栈2.4 读栈顶元素2.5 判空二. 链栈（Linked Stack）1. 定义2. 基本操作2.1 初始化2.2 进栈2.3 出栈2.4 取栈顶元素2.5 判空 一. 顺序栈（Sequential Stack） 1. 定义 #define MaxSize 10 // 定义栈中元素的最大个数 typedef struct {
数据结构实验项目二 栈的基本操作及其应用
WELCOME!!!
11-12 2726
课程名称：数据结构 实验目的： 1．掌握栈的定义及实现； 2．掌握利用栈求解算术表达式的方法。 实验要求： 1、使用链式存储结构完成栈的各种基本操作； 2、补充完成In(c), Preced(t1,t2),Operate(a,theta,b)三个函数。 实验题目：栈的基本操作及其应用 实验过程： 1、通过修改完善教材中的算法3.22，利用栈来实现算术表达式求...
stack的基本定义与使用方法总结
longshaonihaoa的博客
05-28 2083
自己救自己系列， 找工作刷题做点总结。今天依旧是难受的一天，因为刘亦菲还不来娶我！！ 1、栈的定义 栈。属于容器适配器的一种。 容量适配器是一个封装了序列容器的类模板，它在一般序列容器的基础上提供了一些不同的功能。之所以称作适配器类，是因为它可以通过适配容器现有的接口来提供不同的功能。 栈的功能就在于先进后出（FILO）。即只能访问 stack 顶部的元素；只有在移除 stack 顶部的元素后，才能访问下方的元素。 2、基本用法 stack<T> st; ..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值