【数据结构-栈】栈的基本操作

已于 2023-03-12 20:19:07 修改
阅读量2.5k 收藏 17
点赞数 4
分类专栏： # 数据结构与算法 文章标签： 数据结构 算法 c++
于 2022-10-25 17:39:30 首次发布
本文章为作者原创，未经许可禁止转载。
本文链接：https://blog.csdn.net/baidu_39514357/article/details/127518044
版权

文章目录

1 顺序表实现栈

两种实现方式：

  • 栈顶指针 top 指向栈顶元素
  • 栈顶指针 top 指向栈顶元素的下一位置

1.1 定义

# define NUM 50 // 栈的容量

typedef struct Stack{
    int data[NUM];
    int top;
} Stack;

1.2 初始化

  • 栈顶指针 top 指向栈顶元素：
void InitStack (Stack &S){
    S.top = -1;
}
  • 栈顶指针 top 指向栈顶元素的下一位置：
void InitStack (Stack &S){
    S.top = 0;
}

1.3 栈空判断

  • 栈顶指针 top 指向栈顶元素：
bool EmptyStack (Stack &S){
    if (S.top == -1) 
        return true;
    else 
        return false;
}
  • 栈顶指针 top 指向栈顶元素的下一位置：
bool EmptyStack (Stack &S){
    if (S.top == 0) 
        return true;
    else 
        return false;
}

1.4 栈满判断

  • 栈顶指针 top 指向栈顶元素：
bool FullStack (Stack &S){
    if (S.top == NUM-1) 
        return true;
    else 
        return false;
}
  • 栈顶指针 top 指向栈顶元素的下一位置：
bool FullStack (Stack &S){
    if (S.top == NUM) 
        return true;
    else 
        return false;
}

1.5 出栈

  • 栈顶指针 top 指向栈顶元素：
bool PopStack (Stack &S, int &x){
    if (S.top == -1) 
        return false;
    
    x = S.data[S.top];
    S.top--;
    
    return true;
}
  • 栈顶指针 top 指向栈顶元素的下一位置：
bool PopStack (Stack &S, int &x){
    if (S.top == 0) 
        return false;
    
    x = S.data[S.top];
    S.top--;
    
    return true;
}

1.6 入栈

  • 栈顶指针 top 指向栈顶元素：
bool PushStack (Stack &S, const int x){
    if (S.top == NUM-1) 
        return false;
    
    S.top++;
    S.data[S.top] = x;
    
    return true;
}
  • 栈顶指针 top 指向栈顶元素的下一位置：
bool PushStack (Stack &S, const int x){
    if (S.top == NUM) 
        return false;
    
    S.top++;
    S.data[S.top] = x;
    
    return true;
}

1.7 读栈顶元素

  • 栈顶指针 top 指向栈顶元素：
bool GetStackTop (Stack &S, int &x){
    if (S.top == -1) 
        return false;
    
    x = S.data[S.top];
    return true;
}
  • 栈顶指针 top 指向栈顶元素的下一位置：
bool GetStackTop (Stack &S, int &x){
    if (S.top == 0) 
        return false;
    
    x = S.data[S.top-1];
    return true;
}

2 单向链表实现栈

实现方法：

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置（相当于带头结点的链表，头结点正好可以用来记录当前栈存储元素的个数）

【注】“栈顶元素在链表表尾”较难实现，因为单向链表只有后继结点。

2.1 定义

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
#define NUM 50 // 栈的容量

typedef struct LinkNode{
    int data;
    struct LinkNode *next;
} LinkNode, *LinkStack;
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
#define NUM 50 // 栈的容量

typedef struct LinkNode{
    int data;
    struct LinkNode *next;
} LinkNode, *LinkStack;

int count; // 记录栈内当前元素个数

2.2 初始化

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
bool InitStack (LinkStack &top){
    top = NULL;
    count = 0;
    return true;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
bool InitStack (LinkStack &head){
    head = (LinkNode *) malloc(sizeof(LinkNode));
    if (head == NULL)
        return false;
        
    head->data = 0; // 用来记录当前栈存储元素的个数
    head->next = NULL; // 后继结点为空
    return true;
}

2.3 栈空判断

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
void EmptyStack (LinkStack &top){
    if (top == NULL)
        return true;
    return false;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
void EmptyStack (LinkStack &head){
    if (head->data == 0)
        return true;
    return false;
}

2.4 栈满判断

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：需要借助外部变量 count 实现
void FullStack (LinkStack &head){
    if (count == NUM)
        return true;
    return false;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
void FullStack (LinkStack &head){
    if (head->data == NUM)
        return true;
    return false;
}

2.5 出栈

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
bool PopStack (LinkStack &top, int &x){
    LinkNode *topNext; // 记录栈顶结点（表头结点）的下一个结点

    if (top == NULL)
        return false;
    
    x = top->data;
    topNext = top->next; // 记录栈顶结点（表头结点）的下一个结点
    free(top);
    
    count--; // 栈内元素个数减少
    return true;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
bool PopStack (LinkStack &head, int &x){
    LinkNode *top; // 记录表头结点的下一个结点（即栈顶结点）
    LinkNode *topNext; // 记录栈顶结点的下一个结点

    if (head->data == 0)
        return false;
    
    top = head->next; // 记录表头结点的下一个结点（即栈顶结点）
    topNext = top->next; // 记录栈顶结点的下一个结点
    x = top->data;
    free(top);
    
    head->data--; // 栈内元素个数减少
    head->next = topNext;
    return true;
}

2.6 入栈

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
bool PushStack (LinkStack &top, const int x){
    LinkNode *newTop; // 新结点

    newTop = (LinkNode *) malloc(sizeof(LinkNode));
    newTop->data = x;
    newTop->next = top; // 新结点的后继结点指向当前栈顶结点
    
    count++; // 栈内元素增加
    top = newTop; // 新结点作为新的栈顶结点
    return true;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
bool PushStack (LinkStack &head, const int x){
    LinkNode *top; // 记录表头结点的下一个结点（即栈顶结点）
    LinkNode *newTop; // 新结点

    if (head->data == NUM)
        return false;
    
    top = head->next; // 记录表头结点的下一个结点（即栈顶结点）
    topNext = top->next; // 记录栈顶结点的下一个结点
    
    newTop = (LinkNode *) malloc(sizeof(LinkNode));
    newTop->data = x;
    newTop->next = top; // 新结点的下一个结点为当前栈顶结点
    
    head->data++; // 栈内元素个数增加
    head->next = newTop; // 新结点作为表头结点的后继结点
    return true;
}

2.7 读栈顶元素

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
bool GetStackTop(LinkStack top, int &x){
    if (top == NULL)
        return false;
    
    x = top->data;
    return true;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
bool GetStackTop(LinkStack head, int &x){
    LinkNode *top = head->next;
    
    if (head->data == 0)
        return false;
    
    x = top->data;
    return true;
}

3 双向链表实现栈

实现方法：

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素
  • 栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置（相当于带头结点的链表，头结点正好可以用来记录当前栈存储元素的个数）

【注】“栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素的下一位置”没有意义。

3.1 定义

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
  • 栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素：
typedef struct LinkNode{
    int data;
    struct LinkNode *prev;
    struct LinkNode *next;
} LinkNode, *LinkStack;

int count;
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
typedef struct LinkNode{
    int data;
    struct LinkNode *prev;
    struct LinkNode *next;
} LinkNode, *LinkStack;

3.2 初始化

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
bool InitStack (LinkStack &top){
    top = NULL;
    count = 0;
    return true;
}
  • 栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素：
bool InitStack (LinkStack &top){
    top = NULL;
    count = 0;
    return true;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
bool InitStack (LinkStack &head){
    head = (LinkNode *) malloc(sizeof(LinkNode));
    if (head == NULL)
        return false;
        
    head->data = 0; // 用来记录当前栈存储元素的个数
    head->prev = NULL; // 前驱结点为空
    head->next = NULL; // 后继结点为空
    return true;
}

3.3 栈空判断

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
void EmptyStack (LinkStack &top){
    if (top == NULL)
        return true;
    return false;
}
  • 栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素：
void EmptyStack (LinkStack &top){
    if (top == NULL)
        return true;
    return false;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
void EmptyStack (LinkStack &head){
    if (head->data == 0)
        return true;
    return false;
}

3.4 栈满判断

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：需要借助外部变量 count 实现
  • 栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素：需要借助外部变量 count 实现
void FullStack (LinkStack &head){
    if (count == NUM)
        return true;
    return false;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
void FullStack (LinkStack &head){
    if (head->data == NUM)
        return true;
    return false;
}

3.5 出栈

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
bool PopStack (LinkStack &top, int &x){
    LinkNode *topNext; // 记录栈顶结点（表头结点）的下一个结点

    if (top == NULL)
        return false;
    
    x = top->data;
    topNext = top->next; // 记录栈顶结点（表头结点）的下一个结点
    free(top);
    
    count--; // 栈内元素个数减少
    topNext->prev = NULL;
    top = topNext; // 旧栈顶结点（表头结点）的下一个结点成为新的栈顶结点
    return true;
}
  • 栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素：
bool PopStack (LinkStack &top, int &x){
    LinkNode *topPrev; // 记录栈顶结点（表尾结点）的上一个结点

    if (top == NULL)
        return false;
    
    x = top->data;
    topPrev = top->prev; // 记录栈顶结点（表尾结点）的上一个结点
    free(top);
    
    count--; // 栈内元素个数减少
    topPrev->next = NULL;
    top = topNext; // 旧栈顶结点（表尾结点）的上一个结点成为新的栈顶结点
    return true;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
bool PopStack (LinkStack &head, int &x){
    LinkNode *top; // 记录表头结点的下一个结点（即栈顶结点）
    LinkNode *topNext; // 记录栈顶结点的下一个结点

    if (head->data == 0)
        return false;
    
    top = head->next; // 记录表头结点的下一个结点（即栈顶结点）
    topNext = top->next; // 记录栈顶结点的下一个结点
    x = top->data;
    free(top);
    
    head->data--; // 栈内元素个数减少
    head->next = topNext; // 旧栈顶结点（表头结点）的下一个结点成为新的栈顶结点
    topNext->prev = head; // 新栈顶结点的上一个结点为头结点
    return true;
}

3.6 入栈

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
bool PushStack (LinkStack &top, const int x){
    LinkNode *newTop; // 新结点

    newTop = (LinkNode *) malloc(sizeof(LinkNode));
    newTop->data = x;
    newTop->prev = NULL;
    newTop->next = top; // 新结点的后继结点指向当前栈顶结点
    
    count++; // 栈内元素个数增加
    top->prev = newTop; // 当前栈顶结点的前驱结点为新结点
    top = newTop; // 新结点作为新的栈顶结点
    return true;
}
  • 栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素：
bool PushStack (LinkStack &top, const int x){
    LinkNode *newTop; // 新结点

    newTop = (LinkNode *) malloc(sizeof(LinkNode));
    newTop->data = x;
    newTop->prev = top; // 新结点的后继结点指向当前栈顶结点
    newTop->next = NULL;
    
    count++; // 栈内元素个数增加
    top->next = newTop; //当前栈顶结点的后继结点为新结点
    top = newTop; // 新结点作为新的栈顶结点
    return true;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
bool PushStack (LinkStack &head, const int x){
    LinkNode *top; // 记录表头结点的下一个结点（即栈顶结点）
    LinkNode *newTop; // 新结点

    if (head->data == NUM)
        return false;
    
    top = head->next; // 记录表头结点的下一个结点（即栈顶结点）
    
    newTop = (LinkNode *) malloc(sizeof(LinkNode));
    newTop->data = x;
    newTop->prev = head; // 新结点的前驱结点为头结点
    newTop->next = top; // 新结点的后继结点为当前栈顶结点
    
    head->data++; // 栈内元素个数增加
    top->prev = newTop; // 当前栈顶结点的前驱结点指向新结点
    head->next = newTop; // 新结点作为表头结点的后继结点
    return true;
}

3.7 读栈顶元素

  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素：
bool GetStackTop(LinkStack top, int &x){
    if (top == NULL)
        return false;
    
    x = top->data;
    return true;
}
  • 栈顶元素在链表表尾，且栈顶指针 top 指向栈顶元素：
bool GetStackTop(LinkStack top, int &x){
    if (top == NULL)
        return false;
    
    x = top->data;
    return true;
}
  • 栈顶元素在链表表头，且栈顶指针 top 指向栈顶元素的下一位置：
bool GetStackTop(LinkStack head, int &x){
    LinkNode *top = head->next;
    
    if (head->data == 0)
        return false;
    
    x = top->data;
    return true;
}
Mount256
关注
  • 4
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
数据结构---栈的基本操作
Snowzhao的博客
03-17 215
数据结构学习-Unit3栈与队列-栈 大一新生，刚学习数据结构。如有问题，望指正，本人将感激不尽。 栈是一种重要的线性结构，具有后进先出的特性。元素只能从栈顶端压入，也只能从栈顶端弹出。 我们先来看栈的结构： typedef struct stac { int *top; int *bottom; int stacksize; }Stack; t...
数据结构——顺序表的基本操作
cckluv的博客
07-17 373
顺序表的基本功能实现： void SeqListInit(SeqList *plist); void SeqListDestroy(SeqList *plist); void SeqListPushBack(SeqList *plist, ElemType x); void SeqListPushFront(SeqList *plist, ElemType x); void SeqListShow(SeqList *plist); void SeqListPopBack(SeqList *plist);
栈的基本操作
weixin_64084604的博客
11-24 4709
define MaxSize 10 //定义栈中元素的最大个数{//静态数组存放栈中元素int top;//栈顶指针，名叫指针，实则只是一个int型整数来反映栈顶元素的数组下标}SqStack;//后续声明一个顺序栈(分配空间)就 SqStack S;补充解释：（1）顺序存储：给各个数据元素分配连续的存储空间，大小为MaxSize*sizeof(ElemType);（2）结构中定义的int top名为栈顶指针，这里的“指针”和我们所说的数据类型指针实际上不是一回事。
栈的基本操作（详细）
热门推荐
qq_43346784的博客
07-06 1万+
栈的各种基本操作（详细），不看会后悔
C_栈..
PepDokHa的博客
01-20 672
C语言—数据结构 实现栈
数据结构【栈】与基本操作
hshsbabba的博客
03-22 1942
栈及其基本操作
数据结构-栈.zip_数据结构-栈
09-24
标题“数据结构-栈.zip_数据结构-栈”暗示了这个压缩包文件主要包含了关于数据结构中栈的讲解和示例。通过解压并分析其中的文件，我们可以进一步了解栈的基本概念和操作。 “栈测试.cpp”很可能是一个用C++编写的源...
数据结构-栈的基本操作-代码.docx
11-07
栈是一种后进先出（Last In First Out, LIFO）的数据结构，其基本操作包括入栈（Push）、出栈（Pop）、查看栈顶元素（Gettop）以及判断栈是否为空（Stackempty）等。 栈通常用于实现递归、表达式求值、内存分配等...
数据结构-栈相关算法和功能
06-11
总结来说，栈是一种重要的数据结构，它的基本操作和特性使其在解决各种计算问题时起到关键作用。通过深入学习和实践，我们可以更好地利用栈来优化我们的代码和算法设计。同时，了解栈与其他数据结构如队列的差异，也...
数据结构-栈和队列-PPT
02-04
"数据结构-栈和队列-PPT" 数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与...
数据结构学习--栈及其应用
06-25
数据结构学习中，栈是一种非常基础且重要的结构，它被称为后进先出（LIFO，Last In First Out）的数据组织形式。在栈中，新添加的元素（压栈）会在最后，而取出元素（出栈）总是从这些新元素开始，即最先添加的元素...
【数据结构】-栈的基本操作（源码可以直接运行）
m0_61196970的博客
07-18 1532
数据结构对栈的学习。
数据结构之栈的基本操作（顺序栈）
weixin_45945300的博客
12-22 2379
数据结构之栈 语言版本 特点：后进先出（LIFO:last in,first out) 基本操作：栈的初始化、判断空、栈满、取栈顶的元素、在栈顶进行插入和删除； 在栈顶插入元素称为入栈、在栈顶删除元素成为出栈； 在这里插入代码片 typedef struct{ SDatatype *base;//栈底指针 SDatatape *top;//栈顶指针 int StackSize;//栈中定义内存大小 }SqStack; 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markd
【数据结构】栈的基本概念及基本操作
2301_77184700的博客
08-25 699
栈（stack）是只允许在一端进行插入或删除操作的线性表在生活中类似栈的情景有洗碗时碗的堆叠，烤串的连串重要术语：栈顶：允许插入和删除的一端栈底：不允许插入和删除的一端空栈：没有存数据元素的栈。
【数据结构】栈的基本操作
flin666的博客
05-07 4643
文章目录前言一、初始化栈二、销毁栈三、判断栈是否为空四、进栈五、出栈六、取栈顶元素总结 前言 栈的基本操作有1.初始化栈2.销毁栈3.判断栈是否为空4.进栈5.出栈6.取栈顶元素 首先定义好栈的数据类型 typedef int ElemType; typedef struct { ElemType data[MaxSize]; int top; }SqStack; 一、初始化栈 void InitStack(SqStack*& s) { s = (SqStack*)malloc(si
【数据结构】栈的操作
qq_25218219的博客
10-13 752
栈 定义：栈是限定仅在表尾进行插入或删除操作的线性表。 由于栈只有一边开口存取数据，称开口的那一端为“栈顶”，封死的那一端为“栈底”（类似于盛水的木桶，从哪进去的最后还得从哪出来）。 栈操作数据元素的方法 栈操作数据元素只有两种动作： 入栈：在栈顶插入一个元素的操作； 出栈：从栈顶删除一个元素的操作； 栈的“先进后出”原则（Last In First Out） 使用栈存储数据元素，对数据元素的“存”和“取”有严格的规定：数据按一定的顺序存储到栈中，当需要调取栈中某数据元素时，需要将在该数据元素之后
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 279
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
数据结构-栈与队列的概念及操作
"本章介绍了栈和队列这两种重要的数据结构，主要讲解了栈的定义、特点、基本操作以及在C语言中的应用，包括栈与递归函数的关系，同时也介绍了队列的基本概念和应用场景。" 栈是一种特殊的数据结构，它遵循“后进先...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值