栈的顺序存储实现和链式存储实现

最新推荐文章于 2024-07-31 17:17:09 发布
最新推荐文章于 2024-07-31 17:17:09 发布
阅读量289 收藏 1
点赞数
分类专栏： 数据结构 文章标签： c++ 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51141456/article/details/130477961
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

栈

栈(stack)是限制插入和删除只能在线性表的同一端进行一种特殊的线性表。允许插入和删除的一端称为变化端，称为栈顶，通常用一个指针Top指向栈顶位置，另一个固定端称为栈底，通常用一个Bottom指向它。当表中没有元素时称为空栈。

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

一、栈的定义

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

栈的基本操作：

在这里插入图片描述

二、栈常见考题：

题目图解：
在这里插入图片描述

三、栈的顺序存储实现：

栈的顺序结构代码声明：
在这里插入图片描述
代码实现如下：

#include<stdio.h>
#include<string.h>


#define MAXSIZE 256
typedef int ElemType;

typedef struct SNode
{
        ElemType data[MAXSIZE];         //用数组存储顺序表中的元素
        int top;                        //栈顶指针的位置 栈的长度为top+1 栈从0开始
}SeqStack,*PSeqStack;


//栈的初始化操作
void InitStack(PSeqStack SS);

//销毁栈
void DestroyStack(PSeqStack SS);

//清空栈
void clear(PSeqStack SS);

//元素入栈，返回值：0-失败，1-成功
int PushStack(PSeqStack SS,ElemType *ee);

//元素出栈，返回值：0-失败，1-成功
int PopStack(PSeqStack SS,ElemType *ee);

// 求顺序栈的长度，返回值：栈SS中元素的个数。
int Length(PSeqStack SS);


// 判断顺序栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqStack SS);

// 判断顺序栈是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqStack SS);

// 打印顺序栈中全部的元素。
void PrintStack(PSeqStack SS);

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(PSeqStack SS, ElemType *ee);

int main()
{
        SeqStack  SS;           //声明栈

        InitStack(&SS);
        printf("top=%d,SS.data[10]=%d\n",SS.top,SS.data[10]);

        printf("依次将元素 1,2,3,4,6,7,8,9,10入栈\n");
        ElemType ee;

        ee=1; PushStack(&SS,&ee);
        ee=2; PushStack(&SS,&ee);
        ee=3; PushStack(&SS,&ee);
        ee=4; PushStack(&SS,&ee);
        ee=5; PushStack(&SS,&ee);
        ee=6; PushStack(&SS,&ee);
        ee=7; PushStack(&SS,&ee);
        ee=8; PushStack(&SS,&ee);
        ee=9; PushStack(&SS,&ee);
        ee=10; PushStack(&SS,&ee);

        PrintStack(&SS);

        printf("栈的长度为:%d\n",Length(&SS));

        //查看栈顶元素的值，元素不出栈。
        if (GetTop(&SS,&ee)==1)  printf("栈顶的元素值为%d\n",ee);

        PrintStack(&SS);

        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (PopStack(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);


        return 0;
}

//栈的初始化操作
void InitStack(PSeqStack SS)
{
        clear(SS);
        return ;
}



void Destroy(PSeqStack SS)
{
        return ;
}

//清空栈
void clear(PSeqStack SS)
{
        if(SS==NULL){printf("栈不存在。\n");return ;}

        SS->top=-1;
        memset(SS->data,0,sizeof(SS->data));

}


//元素入栈，返回值：0-失败，1-成功
int PushStack(PSeqStack SS,ElemType *ee)
{
        if(SS==NULL ||ee==NULL){printf("栈不存在或者元素不存在。\n");return 0;}

        if(SS->top+1>MAXSIZE)
        {
                printf("栈满，无法入栈。\n");return 0;
        }

        SS->top++;
        memcpy(&SS->data[SS->top],ee,sizeof(ElemType));  // 用数组的下标访问。


        return 1;
}

//元素出栈，返回值：0-失败，1-成功
int PopStack(PSeqStack SS,ElemType *ee)
{
        if(SS==NULL ||ee==NULL){printf("栈不存在者元素不存在。\n");return 0;}
        if (SS->top == -1) { printf("栈为空。\n"); return 0; }

        memcpy(ee,&SS->data[SS->top],sizeof(ElemType));  // 用数组的下标访问。
        SS->top--;
        return 1;
}

// 求顺序栈的长度，返回值：栈SS中元素的个数。
int Length(PSeqStack SS)
{
        if(SS==NULL){printf("栈不存在。\n");return -1;}
        return (SS->top+1);
}

// 判断顺序栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqStack SS)
{

        if(SS==NULL){printf("栈不存在。\n");return 0;}

        if(SS->top==-1)return 1;

        return 0;
}

// 判断顺序栈是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqStack SS)
{
        if(SS==NULL){printf("栈不存在。\n");return 0;}

        if(SS->top+1 >= MAXSIZE)return 1;

        return 0;
}

// 打印顺序栈中全部的元素。
void PrintStack(PSeqStack SS)
{
        if(SS==NULL){printf("栈不存在。\n");return ;}

        if (SS->top == -1) { printf("栈为空。\n"); return; }


        int ii=SS->top;
        while( ii>=0 )
        {
                printf("%-3d ",SS->data[ii]);
                ii--;
        }

        printf("\n");
}

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(PSeqStack SS, ElemType *ee)
{
        if(SS==NULL ||ee==NULL){printf("栈不存在者元素不存在。\n");return 0;}

        if( IsEmpty(SS) ){ printf("栈为空。\n"); return 0; }
        memcpy(ee,&SS->data[SS->top],sizeof(ElemType));  // 用数组的下标访问。 
        return 1;

}

四、链式栈存储实现：

链式栈的存储结构：
typedef int ElemType; // 自定义链栈的数据元素为整数。

typedef struct SNode
{
ElemType data; // 链栈中的元素。
struct SNode *next; // 指向下一个结点的指针。
}SNode,*LinkStack;

下面是链式的代码实现,main函数中加入了一些测试实例：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int ElemType;    // 自定义链栈的数据元素为整数。

typedef struct SNode
{
  ElemType data;       // 链栈中的元素。
  struct SNode *next;  // 指向下一个结点的指针。
}SNode,*LinkStack;


// 链栈SS的初始化操作，分配头结点，返回头结点的地址。
SNode *InitStack();

// 销毁链栈SS。
void DestroyStack(LinkStack SS);

// 元素入栈，返回值：0-失败；1-成功。
int Push(LinkStack SS, ElemType *ee);

// 元素出栈，返回值：0-失败；1-成功。
int Pop(LinkStack SS, ElemType *ee);

// 求链栈的长度，返回值：栈SS中元素的个数。
int  Length(LinkStack SS);

// 清空链栈。
void Clear(LinkStack SS);

// 判断链栈是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(LinkStack SS);

// 打印链栈中全部的元素。
void PrintStack(LinkStack SS);

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(LinkStack SS, ElemType *ee);

int main()
{
        LinkStack ss=InitStack();
        if(ss==NULL)return 0;

        printf("向栈顶插入元素:1,2,3,4,5,6,7,8,9,10。\n");
        ElemType ee;
        ee=1; Push(ss,&ee);
        ee=2; Push(ss,&ee);
        ee=3; Push(ss,&ee);
        ee=4; Push(ss,&ee);
        ee=5; Push(ss,&ee);
        ee=6; Push(ss,&ee);
        ee=7; Push(ss,&ee);
        ee=8; Push(ss,&ee);
        ee=9; Push(ss,&ee);
        ee=10; Push(ss,&ee);

        PrintStack(ss);

         printf("栈的长度是%d\n",Length(ss));

        if (GetTop(ss,&ee)==1)  printf("栈顶的元素值为%d\n",ee);

        PrintStack(ss);

        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (GetTop(ss,&ee)==1)  printf("栈顶的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);
        if (Pop(ss,&ee)==1)  printf("出栈的元素值为%d\n",ee);

         DestroyStack(ss); ss=0;  // 销毁链栈后把SS置为空，防止野指针。
        return 0;
}


// 链栈SS的初始化操作，分配头结点，返回头结点的地址。
SNode *InitStack()
{
        SNode* head=(SNode*)malloc(sizeof(SNode));

        if(head==NULL)return NULL;      //内存不够，分配结点失败

        head->next=NULL;
        return head;
}

// 销毁链栈SS。释放所有结点，包括头结点
void DestroyStack(LinkStack SS)
{
        if(SS==NULL){ printf("栈不存在。\n"); return ; }

        SNode* tmp=SS;

        while(SS!=NULL)
        {
                tmp=SS->next;
                         free(SS);
                SS=tmp;
        }


}

// 元素入栈，返回值：0-失败；1-成功。
int Push(LinkStack SS, ElemType *ee)
{
        if(SS==NULL ||ee==NULL ){ printf("栈不存在或者元素不存在。\n"); return 0; }

        SNode *top=(SNode*)malloc(sizeof(SNode));
        if(top==NULL)return 0;

        //将数据元素的值复制给新结点数据域
        memcpy(&top->data,ee,sizeof(ElemType));

        top->next=SS->next;
        SS->next=top;

        return 1;
}

// 元素出栈，返回值：0-失败；1-成功。
int Pop(LinkStack SS, ElemType *ee)
{
        if(SS==NULL ||ee==NULL ){ printf("栈不存在或者元素不存在。\n"); return 0; }

        //栈顶元素
        SNode *tmp=SS->next;
        if(tmp==NULL){printf("栈为空。\n"); return 0;}
        memcpy(ee,&tmp->data,sizeof(ElemType));

        SS->next=tmp->next;
		free(tmp);
		return 1;
}
// 求链栈的长度，返回值：栈SS中元素的个数。
int  Length(LinkStack SS)
{
        if(SS==NULL){ printf("栈不存在。\n"); return -1; }

        SNode* tmp=SS;
        int len=0;

        while(tmp->next!=NULL)
        {
                tmp=tmp->next;
                len++;
        }

        return len;
}

// 清空链栈。释放除了头结点以外所有结点
void Clear(LinkStack SS)
{
        if(SS==NULL){ printf("栈不存在。\n"); return ; }

        SNode *tmp=SS->next;

        while(SS!=NULL)
        {
                tmp=tmp->next;
                free(SS);
                SS=tmp;
        }

        return ;
}

// 判断链栈是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(LinkStack SS)
{
        if(SS==NULL){ printf("栈不存在。\n"); return 0; }

        if(SS->next==NULL)return 0;

        return 1;
}

// 打印链栈中全部的元素。
void PrintStack(LinkStack SS)
{
        if(SS==NULL){printf("栈不存在。\n");return ;}

        SS=SS->next;
        while(SS!=NULL)
        {
                printf("%3d ",SS->data);
                SS=SS->next;
		}
		printf("\n");
}		

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(LinkStack SS, ElemType *ee)
{
        if(SS==NULL){printf("栈不存在。\n");return 0;}

        SNode *top=SS->next;            //栈顶指针
        if(top==NULL){printf("栈空。\n");return 0;}

        memcpy(ee,&top->data,sizeof(ElemType));

        return 1;
}

总结

相比于单链表，栈的实现显得简单许多，所以只要大家掌握了单链表的代码，完成这章节内容应该相当容易；大家多复习复习单链吧。

菜鸟550号
关注
专栏目录
栈的顺序存储和链式存储实现
qq_68433774的博客
09-07 513
顺序栈与链式栈
栈的链式存储及操作的实现
m0_37546257的博客
10-17 235
链式栈的操作和顺序栈的操作相同，只是在实现上利用了链表的优点进行改进； link_stack.h #ifndef _LINK_STACK_H #define _LINK_STACK_H #include <stdio.h> #include <stdlib.h> #include <string.h> #define STACK_ERR (-1); #define STACK_SUCCESS 0 #define DATA_TYPE_IS_CHAR #if defined
【笔记】栈及其应用
time-space的博客
10-09 493
一栈的定义 二栈的表示和实现 顺序栈的实现 栈的链式表示与实现 三栈的应用 算术表达式求值一、栈的定义  栈是限定仅在表尾进行插入或删除操作的线性表。对栈来说，表尾端具有其特殊含义，称为栈顶，相应地，表头端称为栈底。不含元素的空表称为空栈。栈又称为后进先出的线性表（简称LIFO结构）。二、栈的表示和实现  栈的基本操作只有两个： 入栈（Push）：即将数据保存到栈顶。进行该操作前，先修改栈
C语言 实现栈(顺序表)和队列(链表)
最新发布
SikJ_2020_0_24的博客
07-31 228
实现栈唯一要注意的就是初始化栈的top值,若top = -1;有元素时top指向最后一个元素.若top = 0;有元素时top指向最后一个元素的下一个位置.
数据结构之_栈的顺序存储和链式存储的代码实现
cxu123321的博客
10-15 493
数据结构之_栈的顺序存储和链式存储的代码实现 加入我们QQ群：183791416 致读者的话：曾经的我们很年少，现在我们要为理想的路疯狂的走下去。 目录 数据结构之_栈的顺序存储和链式存储的代码实现 1.栈的基本概念 2.栈的顺序存储代码实现 3.栈的链式存储　　 4.栈的应用(案例) 正文 回到顶部 数据结构之_栈的顺序存储和链式存储的代码实现 1....
栈的顺序存储结构与链式存储结构及代码实现
weixin_43800761的博客
07-11 3674
一、栈的概念 1.1 栈的定义 栈(Stack) ：是只允许在一端进行插入或删除操作的线性表。首 先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除 操作，如图所示：子弹先进后出或后进先出 栈的示意图： 栈顶(Top)： 线性表允许进行插入删除的那一端。 栈底(Bottom)： 固定的，不允许进行插入和删除的另一端。 空栈： 不含任何元素的空表。 进栈（压栈或入栈）： 栈的插入操作 出栈（弹栈）： 栈的删除操作 1.2 栈的基本操作 InitStack(&S)： 初始化-一个空栈 S
栈的顺序存储实现及链式存储实现
CodePanda@GPF的博客
07-09 290
顺序存储实现 #include <stdlib.h> #include <stdlib.h> #define size 100 typedef int ElemType; typedef struct stack{ ElemType s[size]; int top; }stack; void Init(stack **S)//初始化 { *S=(stack *)malloc(sizeof(stack)); (*S)->top=0; } int
栈的顺序表和单链表的实现
m198984的博客
12-12 199
栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中没有元素时称为“空栈”。特点 ：后进先出（LIFO）。 顺序栈 #ifndef __SEQSTACK_H__ #define __SEQSTACK_H__ #include <stdio.h> #include <stdlib.h> #include &...
【数据结构】栈（顺序存储、链式存储）
qq_41563510的博客
05-05 1152
栈（stack）是限定仅在表尾插入和删除操作的线性表。我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出的线性表。
作业 第三章 栈和队列 顺序存储结构和链式存储结构
04-20
在计算机科学中，数据结构是组织、管理和存储数据的方式，它是算法设计的基础。本章主要探讨的是两种常用且基础的数据结构...了解并熟练掌握栈、队列、顺序存储和链式存储结构对于提高编程能力和解决复杂问题至关重要。
第三章 栈和队列 顺序存储结构和链式存储结构
04-20
本章将深入探讨两种重要的数据结构——栈和队列，以及它们的两种常见存储方式：顺序存储结构和链式存储结构。 栈（Stack）被称为“后进先出”（Last In, First Out，简称LIFO）的数据结构。栈的操作主要围绕两个...
数据结构--线性表--栈的顺序存储和链式存储代码实现（c语言实现）
weixin_34689981的博客
01-22 646
栈–C语言代码实现 1.线性表： 首先了解一下线性表的一些基础知识。 ​概念： n个数据元素的有序序列。 结构特点： 存在唯一的一个被称为”第一个“的数据元素。 存在唯一的一个被称为”最后一个“的数据元素。 除第一个元素外，集合中的每个元素都只有一个前驱。 除最后一个元素外，集合中的每个元素都只有一个后继。 顺序表示： ​ 用一组地址连续的存储单元依次存储线性表中的数据元素。 ​ 线性表的这种机内表示称为线性表的顺序存储或顺序印象，这种存储结构的线性表为顺序表。 ​ 通常用数组来描述顺序存储
栈之链式存储基本操作
靡不有初鲜克有终
02-05 521
#include #include //栈的链式存储结构 typedef char ElemType; typedef struct linknode { ElemType data;//数据域 struct linknode *next;//指针域 }LiStack; //初始化栈 void InitStack(LiStack *&s) { s=(LiStack *)
栈的链式存储的基本操作
苍之羽
01-21 2807
1 :链式存储结构 　　栈的链式存储结构，简称链栈。 　　由于栈只是栈顶在做插入和删除操作，所以栈顶应该放在单链表的头部。另外，都有了栈顶在头部了，单链表中的头结点也就失去了意义，通常对于链栈来说，是不需要头结点的。 　　对于链栈来说，基本不存在栈满的情况，除非内存已经没有使用空间了。 　　对于空栈来说，链表原来的定义是头指针指向空，那么链栈的空其实就是top＝NULL。 #include&amp;amp;amp;amp;amp;lt;...
栈的顺序表和链表实现，以及一些涉及到栈思想的题目
ypeijasd的专栏
05-19 417
一、std里面栈的基本操作 #include <stdio.h> #include <stack> //使用命名空间std using namespace std; stack<char> s; int main() { //判断栈是否为空 if(s.empty()){ printf("空\n"); } else{ printf("非空\n"); } char asd='a'; //入栈 s.push(asd); s.push
栈的顺序和链式的实现
Euphoria_stars的博客
09-11 175
数据结构
栈的链式存储和操作实现
jhlyh的博客
03-27 124
#ifndef STACK_H_INCLUDED #define STACK_H_INCLUDED typedef int ElemType; typedef struct SingleNode { ElemType data; struct SingleNode* next; }Stack; #endif #include <stdio.h> #include <stdlib.h> #include "Stack.h" /*************************
栈的链式存储结构基本实现
LZ_Yun的博客
03-22 704
栈的链式存储结构基本操作
栈的链式存储结构操作及实现
Feynman1999的博客
03-21 790
栈的链式存储结构操作及实现 /* 栈的链式存储结构操作及实现 */ #include #include #include #include using namespace std; typedef int SElemType; //这里用int示例 typedef struct StackNode //节点的定义 { SElemType data; struct StackNod
顺序与链式存储：线性表实现详解
本篇文档主要讨论了线性表的两种基本存储实现方式：顺序存储和链式存储。在数据结构课程设计中，学生需要实现这两种数据结构，包括它们的抽象数据类型(ADT)中的基本操作。以下是详细的解析： 1. **需求分析** - **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值