顺序栈与链式栈

最新推荐文章于 2022-08-23 16:17:18 发布
最新推荐文章于 2022-08-23 16:17:18 发布
阅读量524 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nessie_zhao/article/details/79834404
版权

栈

首先先对栈做简单的认识：

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。栈也称为后进先出表。
这里写图片描述

下面是实现顺序栈与链式栈的程序：

1.顺序栈

.h文件
#pragma once

#include<stddef.h>

typedef char SeqStackType;

typedef struct SeqStack
{
    SeqStackType* data;
    size_t size;
    size_t capacity;//max_size 的代替品，data这段内存中能容纳的元素个数
}SeqStack;

void SeqStackInit(SeqStack* stack);//栈的初始化
void SeqStackDestroy(SeqStack* stack);//栈的销毁
void SeqStackResize(SeqStack* stack);//重新设置栈的大小
void SeqStackPush(SeqStack* stack,SeqStackType value);//入栈
void SeqStackPop(SeqStack* stack);//出栈
//返回两个信息：执行成功失败，栈顶元素的值是多少
int SeqStackTop(SeqStack* stack,SeqStackType* value);
.c文件
#include"seqstack.h"
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdio.h>
#define TEST_HEADER printf("\n==============================%s====================================\n",__FUNCTION__);
void SeqStackPrintChar(SeqStack* stack,const char* msg)
{
    printf("[%s]\n",msg);
    size_t i = 0;
    for(;i < stack->size;++i)//循环打印栈中元素
    {
       printf("[%c] ",stack->data[i]) ;
    }
    printf("\n");
    return;
}
初始化以及测试函数
void SeqStackInit(SeqStack* stack)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    stack->size = 0;//将栈的大小设置为0
    stack->capacity = 1000;//将栈的最大容纳元素个数设置为1000
    stack->data = (SeqStackType*)malloc(stack->capacity*sizeof(SeqStackType));
}
void TestInit()
{
    TEST_HEADER;
    SeqStack stack;
    SeqStackInit(&stack);
    printf("size expected : 0,actual %lu\n",stack.size);
    printf("capacity expected : 1000,actual %lu\n" ,stack.capacity);
}
销毁栈
void SeqStackDestroy(SeqStack* stack)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    free(stack->data);
    stack->size = 0;
    stack->capacity = 0;
}
void TestDestroy()
{
    TEST_HEADER;
    SeqStack stack;
    SeqStackInit(&stack);
    SeqStackDestroy(&stack);
    printf("size expected : 0,actual %lu\n",stack.size);
    printf("capacity expected : 0,actual %lu\n" ,stack.capacity);
}
入栈
void SeqStackResize(SeqStack* stack)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    if(stack->size < stack->capacity)//如果栈的大小比最大容纳元素个数小不需要重置大小
    {
        return;
    }
    stack->capacity = stack->capacity * 2 + 1;//根据自己的喜好进行扩容
    SeqStackType* new_ptr = (SeqStackType*)malloc(stack->capacity * sizeof(SeqStackType));
    size_t i = 0;
    for(;i <stack->size;++i )
    {
        new_ptr[i] = stack->data[i];//将原栈中元素放到新开辟的空间
    }
    free(stack->data);
    stack->data = new_ptr;
    return;
}
void SeqStackPush(SeqStack* stack,SeqStackType value)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    if(stack->size > stack->capacity)//如果栈的大小已经超出最大的容量，则新开辟空间
    {
        SeqStackResize(stack);
    }
    stack->data[stack->size++] = value;//否则直接把值赋给下一个元素，size++
    return;
}
void TestPush()
{
    TEST_HEADER;
    SeqStack stack;
    SeqStackInit(&stack);
    SeqStackPush(&stack,'a');
    SeqStackPush(&stack,'b');
    SeqStackPush(&stack,'c');
    SeqStackPush(&stack,'d');
    SeqStackPrintChar(&stack,"入栈四个元素");
}
出栈
void SeqStackPop(SeqStack* stack)
{
    if(stack == NULL)
    {
        //非法输入
        return;
    }
    if(stack->size == 0)
    {
        return;
    }
    --stack->size;
    return;
}
void TestPop()
{
    TEST_HEADER;
    SeqStack stack;
    SeqStackInit(&stack);
    SeqStackPush(&stack,'a');
    SeqStackPush(&stack,'b');
    SeqStackPush(&stack,'c');
    SeqStackPush(&stack,'d');
    SeqStackPop(&stack);
    SeqStackPrintChar(&stack,"出栈一个元素");
    SeqStackPop(&stack);
    SeqStackPop(&stack);
    SeqStackPrintChar(&stack,"出栈两个元素");
    SeqStackPop(&stack);
    SeqStackPop(&stack);
    SeqStackPrintChar(&stack,"出栈两个元素");
}
取栈顶元素
int SeqStackTop(SeqStack* stack,SeqStackType* value)
{
    if(stack == NULL || value == NULL)
    {
        //非法输入
        return 0;
    }
    if(stack->size == 0)
    {
        //空栈
        return 0;
    }
    *value = stack->data[stack->size-1];
    return 1;
}
void TestTop()
{
    TEST_HEADER;
    SeqStack stack;
    SeqStackInit(&stack);
    SeqStackPush(&stack,'a');
    SeqStackPush(&stack,'b');
    SeqStackPush(&stack,'c');
    SeqStackPush(&stack,'d');
    SeqStackPrintChar(&stack,"入栈四个元素");

    SeqStackType value;
    int ret = SeqStackTop(&stack,&value);
    printf("ret expected : 1，actual %d\n",ret);
    printf("value expected : d,actual %c\n",value);

    SeqStackPop(&stack);
    SeqStackPop(&stack);
    ret = SeqStackTop(&stack,&value);
    printf("ret expected : 1，actual %d\n",ret);
    printf("value expected : b,actual %c\n",value);

    SeqStackPop(&stack);
    SeqStackPop(&stack);
    ret = SeqStackTop(&stack,&value);
    printf("ret expected : 0，actual %d\n",ret);
}

2.链式栈
.h文件

#pragma once

typedef char LinkStackType;

typedef struct LinkNode
{
    LinkStackType data;
    struct LinkNode* next;
}LinkNode;

typedef struct LinkStack
{
    LinkNode* head;
    LinkNode* tail;
}LinkStack;

void LinkStackInit(LinkStack* s);//初始化
void LinkStackDestroy(LinkStack* s);//销毁栈
void LinkStackPush(LinkStack* s,LinkStackType value);//入栈
void LinkStackPop(LinkStack* s);//出栈
int LinkStackTop(LinkStack* s ,LinkStackType* value);//取栈顶元素

.c文件

#include"linkstack.h"
#include <stdio.h>
#include<stdlib.h>
void LinkStackInit(LinkStack* s)
{
    if(s == NULL)
    {
        //非法输入
        return;
    }
    s->head = NULL;//将头指针置空
    s->tail = NULL;//将尾指针置空
    return;
}
void LinkStackDestroy(LinkStack* s)
{
    if(s == NULL)
    {
        //非法输入
        return;
    }
    LinkNode* cur = s->head;
    LinkNode* pre = cur;
    while(cur!=NULL)
    {
        pre = cur;
        cur = cur->next;
        free(pre);
        pre = NULL;
    }
    return;
}
LinkNode* CreateLinkStackNode(LinkStackType value)
{
    LinkNode* tmp = (LinkNode*)malloc(sizeof(LinkNode));
    if(!tmp)
    {
        //创建失败
        return NULL;
    }
    tmp->data = value;
    tmp->next = NULL;//将新建节点的next置空
    return tmp;
}
void LinkStackPush(LinkStack* s,LinkStackType value)
{
    if(s == NULL)
    {
        return;
    }
    LinkNode* cur = CreateLinkStackNode(value);//创建一个新的值为value的节点
    cur->next = s->head;//将新创建的节点的next指向原栈的顶部
    s->head = cur;//更新头指针的指向
    return;
}
void DestroyLinkStackNode(LinkNode* to_delete)
{
    if(to_delete == NULL)
    {
        return;
    }
    free(to_delete);
    to_delete = NULL;
    return;
}

void LinktackPop(LinkStack* s)
{
    if(s == NULL)
    {
        return;
    }
    LinkNode* to_delete = s->head;//出栈出的是栈顶元素
    s->head = s->head->next;//原头节点的next为新的头节点
    DestroyLinkStackNode(to_delete);
    return;
}
int LinkStackTop(LinkStack* s,LinkStackType* value)
{
    if(s == NULL || value == NULL)
    {
        return 0;
    }
    if(s->head == NULL)
    {
        return 0;
    }
    *value = s->head->data;//将头节点的值赋给value
    return 1;//有元素返回1
}

以下为测试代码：

#if 1
#define TEST_HEADER printf("\n=========================%s===================================\n",__FUNCTION__);
void TestStack()
{
    TEST_HEADER;
    LinkStack stack;
    LinkStackInit(&stack);
    //首先入栈四个元素
    LinkStackPush(&stack,'a');
    LinkStackPush(&stack,'b');
    LinkStackPush(&stack,'c');
    LinkStackPush(&stack,'d');

    LinkStackType value;
    int ret = LinkStackTop(&stack,&value);
    //因为栈满足后进先出原则，所以第一个栈顶元素为d 
    printf("ret expected : 1,actual %d\n",ret);
    printf("value expected : d,actual %c\n",value);
    //出栈一个元素后栈顶元素变为c
    LinktackPop(&stack);
    ret = LinkStackTop(&stack,&value);
    printf("ret expected : 1,actual %d\n",ret);
    printf("value expected : c,actual %c\n",value);
    LinktackPop(&stack);
    ret = LinkStackTop(&stack,&value);
    printf("ret expected : 1,actual %d\n",ret);
    printf("value expected : b,actual %c\n",value);
    LinktackPop(&stack);
    ret = LinkStackTop(&stack,&value);
    printf("ret expected : 1,actual %d\n",ret);
    printf("value expected : a,actual %c\n",value);
    LinktackPop(&stack);
    ret = LinkStackTop(&stack,&value);
    printf("ret expected : 0,actual %d\n",ret);
}

int main()
{
    TestStack();
    return 0;
}
#endif
Nessie_zhao
关注
专栏目录
数据结构 顺序栈、链式栈
ZY-JIMMY
01-08 1275
目录 栈的定义 顺序栈 顺序栈的扩容 链式栈 顺序栈的实现 顺序栈(扩容)的实现 链式栈的实现 栈的定义 栈(STACK) 是 限定在表尾进行插入和删除操作的线性表 栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈也...
顺序栈与链式栈的图解与实现
AnonyStar | Blog
12-09 1497
# 顺序栈与链式栈的图解与实现 栈是一种特殊的线性表，它与线性表的区别体现在增删操作上 栈的特点是先进后出，后进先出，也就是说栈的数据操作只能发生在末端，而不允许在中间节点进行操作 如上图所示，对栈的增删操作都只能在末端也就是栈顶操作， 栈既然是线性表那么就存在表头和表尾，不过在栈结构中，对其都进行限制改造，表尾用来输入数据也叫做栈顶（top）,相应的 表头就是栈底（bottom），栈顶和栈顶是两个指针用来表示这个栈 与线性表类似，栈也是又顺序表示和链式表示，分别称作顺序栈和链栈 栈的基本操作
顺序栈/链式栈
sandmm112的博客
04-09 1万+
        栈是是一种限定性的线性表，它将线性表的插入和删除限定为仅在表的一端进行。将表中允许插入和删除的一端成为栈顶。所以栈顶的位置是不断动态变化的。它具有“后进先出”的特点。因为栈是由线性表实现的，所以，栈有两种存储结构：顺序存储和链式存储。对应的栈成为顺序栈和链式栈。下面，分别来介绍这两种栈的相关操作。一，顺序栈        它与顺序表类似，即用一组地址连续的空间存放栈中的元素。之前的...
顺序栈和链式栈
qq_26646107的博客
07-25 162
栈是一种只允许在表的一端进行操作的数据结构，插入操作称为进栈，删除操作称为入栈。 顺序栈是指采用顺序存储的结构的栈，即在内存中用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时设置一个top指针，指示栈顶元素的当前位置。 在这里插入代码片 #include<stdio.h> #include<stdlib.h> #define MAX_SIZE 100 #define true 0 #define false 1 typedef struct { int data[MAX
数据结构顺序栈与链式栈基本操作
最新发布
12-30
顺序栈和链式栈是两种常见的栈的实现方式。顺序栈是用一组地址连续的存储单元依次存储栈中的元素，每个元素占用一个存储单元。链式栈是用一组节点指针来存储栈中的元素，每个节点中包含数据和指向下一个节点的指针。...
C++ 顺序栈和链式栈的实现 数据结构 类模板
02-03
本主题将深入探讨两种常见的栈实现：顺序栈和链式栈，并使用类模板来增强其通用性。栈是一种特殊的线性数据结构，遵循“后进先出”（LIFO）原则，即最后进入的元素最先出来。 ### 顺序栈的实现 顺序栈通常使用数组...
顺序表、链式表、顺序栈、链式栈以及顺序队列、链式队列
weixin_65012900的博客
08-06 493
数据结构 表 栈 队列
【数据结构】堆栈（顺序栈、链式栈）
火山君的博客
03-03 1873
一、栈的定义 1、术语： 栈（stack）：是一种只允许在表的一端进行插入或删除操作的线性表。 栈顶：表尾端，即表中允许进行插入和删除操作的一端称为栈顶。栈顶是动态的，它由一个称为栈顶指针的位置指示器指示。 栈底：表头端，即栈的最下面的那一端称为栈底。 空栈：没有元素的栈 进栈或入栈：堆栈的插入操作 出栈或退栈：堆栈的删除操作 2、栈的特点： “后进先出”，因此，...
线性表，顺序表，顺序栈，链式栈
06-10
这是我原来实现的一些数据结构（C++实现）有：线性表，顺序表，顺序栈，链式栈。此代码供大家学习参考！
栈（顺序栈、链式栈）
m0_65213200的博客
08-23 209
顺序栈、链式栈
栈，顺序栈，链栈
爱吃鱼的ねこ的博客
04-01 725
        栈作为一种限定性线性表，是将表的插入删除限制为仅在表的一端进行，通常将表中允许插入删除的一端叫做栈顶（top)，因此栈顶的当前位置是动态变化的。栈的另一端叫做栈底（bottom)。当栈中没有元素时称为空栈。插入操作称为进栈或入栈，删除操作称为出栈或退栈。栈是先进后出的线性表，简称为LIFO表。 &nbs...
C++栈学习——顺序栈和链栈的区别
热门推荐
千里之行始于足下
08-24 1万+
C++中栈有顺序栈和链栈之分，在顺序栈中，定义了栈的栈底指针（存储空间首地址base）、栈顶指针top以及顺序存储空间的大小stacksize（个人感觉这个数据成员是可以不用定义的） //顺序栈数据结构C++类声明（基类） template <typename ElemType> class SqStack { public: void clear();
史上最全 顺序栈和链栈
qq_45288176的博客
06-11 2830
■ 栈(stack) 是一个特殊的线性表，是限定仅在一端(通常是表尾)进行插入和删除操作的线表。 ■ 又称为后进先出(Last In First Out)的线性表，简称LIFO结构。
数据结构--顺序栈和链式栈
sinat_35297665的博客
10-26 382
http://www.cnblogs.com/jingliming/p/4602458.html 栈是一种限定只在表尾进行插入或删除操作,栈也是线性表表头称为栈的底部,表尾称为栈的顶部,表为空称为空栈，栈又称为后进先出的线性表,栈也有两种表示:顺序栈与链式栈顺序栈是利用一组地址连续的存储单元，依次存放从栈底到栈顶的数据元素,附设一个指针指示栈顶的元素在栈中的位置。      
链栈和顺序栈的实现
Selfmotivational的博客
01-16 447
链栈： # include # include typedef char NodeData; typedef struct Node { NodeData data; struct Node *next; }StackNode; typedef struct { StackNode *top; } LinkStack; //栈置空 void initStac
C语言实现括号匹配：顺序栈与链式栈
该资源主要介绍了如何使用C语言实现顺序栈和链栈的数据结构，并通过一个具体的例子——括号匹配，来展示栈的应用。内容包括实验目的、顺序栈的定义、基本操作的实现以及链栈的实现。 1. 实验目标： - 学生需要掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值