数据结构——顺序栈和链式栈

于 2024-08-21 23:51:00 发布
阅读量447 收藏 12
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80401288/article/details/141371247
版权

目录

引言

栈的定义

栈的分类

栈的功能

栈的声明

1.顺序栈

2.链式栈

栈的功能实现

1.栈的初始化

(1)顺序栈

(2)链式栈

(3)复杂度分析

2.判断栈是否为空

(1)顺序栈

(2)链式栈

(3)复杂度分析

3.返回栈顶元素

(1)顺序栈

(2)链式栈

(3)复杂度分析

4.返回栈的大小

(1)顺序栈

(2)链式栈

(3)复杂度分析

5.元素入栈

(1)顺序栈

(2)链式栈

(3)复杂度分析

6.元素出栈

(1)顺序栈

(2)链式栈

(3)复杂度分析

7.打印栈的元素

(1)顺序栈

(2)链式栈

(3)复杂度分析

8.销毁栈

(1)顺序栈

(2)链式栈

(3)复杂度分析

顺序栈和链式栈的对比

完整代码

1.顺序表

2.链式表

结束语

引言

在学习完链表之后，我们接下来学习数据结构——栈的内容。

栈的定义

栈（Stack）是一种遵循后进先出（LIFO, Last In First Out）原则的有序集合。这种数据结构只允许在栈顶进行添加（push）或删除（pop）元素的操作。换句话说，最后添加到栈中的元素将是第一个被移除的，就像一叠盘子那样，我们只能从上面开始取放盘子。

如图所示：

栈顶（Top）：栈顶是栈中最后添加（push）元素的位置，也是最先被移除（pop）或查看（peek/top）的元素所在的位置。在栈的所有操作中，无论是添加、删除还是查看元素，都是针对栈顶进行的。因此，栈顶是栈中最活跃、最频繁被访问的位置。

栈底（Bottom）：栈底是栈中最早被添加进去的元素所在的位置，也是栈中唯一一个固定不变的位置（除非整个栈被清空）。在栈的常规操作中，栈底元素不会被直接访问，除非是将整个栈的内容倒序输出或者栈被完全清空。因此，栈底在栈的操作中扮演的是一个相对静态的角色。

栈的分类

栈可以分为顺序栈与链式栈。

如下图所示：

顺序栈：

链式栈：

栈的功能

我们要实现的栈的功能如下所示：

1.栈的初始化。
2.判断栈是否为空。
3.返回队头元素。
4.返回栈的大小。
5.元素入栈。

6.元素出栈。
7.打印栈的元素。
8.销毁栈。

栈的声明

1.顺序栈

顺序栈的声明需要一个指向一块空间的指针a，指向栈顶下一个元素的top，以及标志栈空间大小的capacity。

声明如下：

typedef int STDataType;

typedef struct STDataType
{
	STDataType* a;
	int top;
	int capacity;
}ST;

2.链式栈

链式栈的声明只需要一个top指针，以及栈的容量capacity。

当然这里需要链表的声明。

代码如下：

typedef int STDataType;

typedef struct SListNode
{
	STDataType data;
	struct SListNode* next;
}SLTNode;

typedef struct Stack
{
	// 指向栈顶节点的指针
	SLTNode* top;
	int size;
}ST;

栈的功能实现

1.栈的初始化

顺序栈和链式栈都可以先初始为NULL。

(1)顺序栈

顺序栈可以将top设置为-1，capacity设置为0。

代码如下：

//栈的初始化
void STInit(ST* st)
{
	assert(st);
	st->a = NULL;
	st->top = -1;
	st->capacity = 0;
}
(2)链式栈

链式栈将size设置为0，top设置为NULL。

代码如下：

//栈的初始化
void STInit(ST* st)
{
	assert(st);
	st->size = 0;
	st->top = NULL;
}
(3)复杂度分析

时间复杂度：由于顺序栈和链式栈花费时间都是一个常数，因此时间复杂度为O(1)。

空间复杂度：由于顺序栈和链式栈花费空间都是一个固定大小的空间，因此空间复杂度为O(1)。

2.判断栈是否为空

判断栈是否为空只需要判断top的指向。

(1)顺序栈

当top=-1则为空。

代码如下：

//判空
bool STEmpty(ST* st)
{
	assert(st);
	return st->top == -1;
}
(2)链式栈

判断top是否指向NULL。

代码如下：

//判空
bool STEmpty(ST* st)
{
	return (st->top == NULL);
}
(3)复杂度分析

时间复杂度：由于顺序栈和链式栈花费时间都是一个常数，因此时间复杂度为O(1)。

空间复杂度：由于顺序栈和链式栈花费空间都是一个固定大小的空间，因此空间复杂度为O(1)。

3.返回栈顶元素

(1)顺序栈
//取出栈顶数据
STDataType STTop(ST* st)
{
	assert(st);
    // 断言确保栈不为空（即栈顶索引不小于0）
	assert(st->top >= 0);
	return st->a[st->top];
}
(2)链式栈
//取出栈顶数据
STDataType STTop(ST* st)
{
	assert(st);
	assert(!STEmpty(st));
	return st->top->data;
}
(3)复杂度分析

时间复杂度：由于顺序栈和链式栈花费时间都是一个常数，因此时间复杂度为O(1)。

空间复杂度：由于顺序栈和链式栈花费空间都是一个固定大小的空间，因此空间复杂度为O(1)。

4.返回栈的大小

(1)顺序栈

由于在一开始将top设置为-1，需要top+1才能符合需要。

代码如下：

//获取数据个数
STDataType STSize(ST* st)
{
	assert(st);
	return st->top + 1;
}
(2)链式栈
//获取数据个数
STDataType STSize(ST* st)
{
	return st->size;
}
(3)复杂度分析

时间复杂度：由于顺序栈和链式栈花费时间都是一个常数，因此时间复杂度为O(1)。

空间复杂度：由于顺序栈和链式栈花费空间都是一个固定大小的空间，因此空间复杂度为O(1)。

5.元素入栈

注意：入栈需要检查空间是否足够。

(1)顺序栈

由于top设置的是-1，因此需要先腾出空间然后再将新元素x放在栈顶。

代码如下：

//入栈
void STPush(ST* st, STDataType x)
{
	assert(st);
	// 注意：由于top初始化为-1，所以满的条件是top == capacity - 1
	if (st->top == st->capacity - 1)
	{
		// 如果栈已满，则扩展栈的容量
		int newcapacity = st->capacity == 0 ? 4 : st->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(st->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail：");
			return;
		}
		st->a = tmp;
		st->capacity = newcapacity;
	}
	// 增加栈顶索引，为新元素腾出空间
	st->top++;
	// 将新元素x存储在栈顶位置
	st->a[st->top] = x;
}
(2)链式栈
//入栈
void STPush(ST* st, STDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail:");
		return;
	}
	// 新节点的next指向原来的栈顶
	newnode->next = st->top;

	// 设置新节点的数据
	newnode->data = x;

	// 更新栈顶为新节点
	st->top = newnode;
	st->size++;
}
(3)复杂度分析

时间复杂度：由于顺序栈支持下标的随机访问并且我们以单链表的头作为栈顶，因此时间复杂度为O(1)。

空间复杂度：顺序表又可能需要进行扩容处理，最坏的情况是空间复杂度为O(n)。链式表每次入栈固定为一个节点，因此空间复杂度为O(1)。

6.元素出栈

(1)顺序栈
//出栈
void STPop(ST* st)
{
	assert(st);
	assert(st->top >= 0);
	st->top--;
}
(2)链式栈
//出栈
void STPop(ST* st)
{
	assert(st);
	assert(!STEmpty(st));
	// 获取栈顶节点的下一个节点
	SLTNode* next = st->top->next;
	free(st->top);
	// 更新栈顶指针，使其指向新的栈顶节点
	st->top = next;
	st->size--;
}
(3)复杂度分析

时间复杂度：由于顺序栈还是链式栈花费时间都是一个常数，因此时间复杂度为O(1)。

空间复杂度：由于顺序栈和链式栈花费空间都是一个固定大小的空间，因此空间复杂度为O(1)。

7.打印栈的元素

(1)顺序栈
//栈的打印
void STPrint(ST* st)
{
	assert(st);
	assert(!STEmpty(st));
	// 从栈顶开始打印，直到栈底（但不包括索引-1）
	for (int i = st->top; i >= 0; i--)
	{
		printf("%d ", st->a[i]);
	}
}
(2)链式栈
//栈的打印
void STPrint(ST* st)
{
	assert(st);
	assert(!STEmpty(st));
	for (SLTNode* top = st->top; top != NULL; top = top->next)
	{
		printf("%d ", top->data);
	}
}
(3)复杂度分析

时间复杂度：由于顺序栈和链式栈打印都需要遍历整个栈，因此时间复杂度为O(N)。

空间复杂度：由于顺序栈和链式栈花费空间都是一个固定大小的空间，因此空间复杂度为O(1)。

8.销毁栈

(1)顺序栈
//栈的销毁
void STDestory(ST* st)
{
	assert(st);
	free(st->a);
	st->a = NULL;
	st->capacity = 0;
	st->top = -1;
}
(2)链式栈
//栈的销毁
void STDestory(ST* st) 
{
	assert(st);
	SLTNode* top = st->top;
	while (top != NULL)
	{
		SLTNode* next = top->next;
		free(top);
		top = next;
	}
	st->size = 0;
}
(3)复杂度分析

时间复杂度：由于顺序栈还是链式栈花费时间都是一个常数，因此时间复杂度为O(1)。

空间复杂度：由于顺序栈和链式栈花费空间都是一个固定大小的空间，因此空间复杂度为O(1)。

顺序栈和链式栈的对比

顺序栈链式栈
数据结构使用动态数组实现，元素在物理内存中连续存储使用链表实现，元素通过节点和指针连接，内存空间不连续
内存管理栈空间不足时可动态扩容，释放整个栈时一次性释放内存节点内存单独分配和释放，需要遍历链表以释放所有节点内存
时间效率可以通过数组下标直接访问栈内任意位置的元素，但是这不符合栈的定义由于每次都需要扩容操作，所以效率略比顺序栈低
空间效率顺序栈的扩容较大可能会造成空间的浪费内存使用相对灵活，但每个节点需要额外存储指针

完整代码

1.顺序表

Stack.h

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

typedef int STDataType;

typedef struct STDataType
{
	STDataType* a;
	int top;
	int capacity;
}ST;

//栈的初始化
void STInit(ST* st);

//栈的销毁
void STDestory(ST* st);

//入栈
void STPush(ST* st, STDataType x);
//出栈
void STPop(ST* st);

//取出栈顶数据
STDataType STTop(ST* st);

//判空
bool STEmpty(ST* st);

//获取数据个数
STDataType STSize(ST* st);

//栈的打印
void STPrint(ST* st);

Stack.c

#include"Stack.h"

//栈的初始化
void STInit(ST* st)
{
	assert(st);
	st->a = NULL;
	st->top = -1;
	st->capacity = 0;
}

//栈的销毁
void STDestory(ST* st)
{
	assert(st);
	free(st->a);
	st->a = NULL;
	st->capacity = 0;
	st->top = -1;
}

//入栈
void STPush(ST* st, STDataType x)
{
	assert(st);
	// 注意：由于top初始化为-1，所以满的条件是top == capacity - 1
	if (st->top == st->capacity - 1)
	{
		// 如果栈已满，则扩展栈的容量
		int newcapacity = st->capacity == 0 ? 4 : st->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(st->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		st->a = tmp;
		st->capacity = newcapacity;
	}
	// 增加栈顶索引，为新元素腾出空间
	st->top++;
	// 将新元素x存储在栈顶位置
	st->a[st->top] = x;
}

//出栈
void STPop(ST* st)
{
	assert(st);
	assert(st->top >= 0);
	st->top--;
}

//取出栈顶数据
STDataType STTop(ST* st)
{
	assert(st);
	assert(st->top >= 0);
	return st->a[st->top];
}

//判空
bool STEmpty(ST* st)
{
	assert(st);
	return st->top == -1;
}

//获取数据个数
STDataType STSize(ST* st)
{
	assert(st);
	return st->top + 1;
}

//栈的打印
void STPrint(ST* st)
{
	assert(st);
	assert(!STEmpty(st));
	// 从栈顶开始打印，直到栈底（但不包括索引-1）
	for (int i = st->top; i >= 0; i--)
	{
		printf("%d ", st->a[i]);
	}
}

2.链式表

Stack.h

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

typedef int STDataType;

typedef struct SListNode
{
	STDataType data;
	struct SListNode* next;
}SLTNode;

typedef struct Stack
{
	// 指向栈顶节点的指针
	SLTNode* top;
	int size;
}ST;

//栈的初始化
void STInit(ST* st);

//栈的销毁
void STDestory(ST* st);

//入栈
void STPush(ST* st, STDataType x);

//出栈
void STPop(ST* st);

//取出栈顶数据
STDataType STTop(ST* st);

//判空
bool STEmpty(ST* st);

//获取数据个数
STDataType STSize(ST* st);

//栈的打印
void STPrint(ST* st);

Stack.c

#include"Stack.h"

//栈的初始化
void STInit(ST* st)
{
	assert(st);
	st->size = 0;
	st->top = NULL;
}

//栈的销毁
void STDestory(ST* st) 
{
	assert(st);
	SLTNode* top = st->top;
	while (top != NULL)
	{
		SLTNode* next = top->next;
		free(top);
		top = next;
	}
	st->size = 0;
}

//入栈
void STPush(ST* st, STDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail:");
		return;
	}
	// 新节点的next指向原来的栈顶
	newnode->next = st->top;

	// 设置新节点的数据
	newnode->data = x;

	// 更新栈顶为新节点
	st->top = newnode;
	st->size++;
}

//出栈
void STPop(ST* st)
{
	assert(st);
	assert(!STEmpty(st));
	// 获取栈顶节点的下一个节点
	SLTNode* next = st->top->next;
	free(st->top);
	// 更新栈顶指针，使其指向新的栈顶节点
	st->top = next;
	st->size--;
}

//取出栈顶数据
STDataType STTop(ST* st)
{
	assert(st);
	assert(!STEmpty(st));
	return st->top->data;
}

//判空
bool STEmpty(ST* st)
{
	return (st->top == NULL);
}

//获取数据个数
STDataType STSize(ST* st)
{
	return st->size;
}

//栈的打印
void STPrint(ST* st)
{
	assert(st);
	assert(!STEmpty(st));
	for (SLTNode* top = st->top; top != NULL; top = top->next)
	{
		printf("%d ", top->data);
	}
}

结束语

本篇博客简要介绍了一下栈，接下来我们将接着学习与栈有些类似的另一个数据结构——队列。

数据结构——链式队列和循环队列

感谢各位大佬们的支持！！！

求点赞收藏关注！！！

十分感谢！！！

qing_040603
关注
  • 14
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习——顺序栈和链式栈的简单实现和解析（C语言版）
正弦定理的博客
11-26 1250
数据结构——栈的简单解析和实现一、概念二、入栈（push）三、出栈（pop）四、顺序栈简单实现（1）进栈操作（2）出栈操作 一、概念 本篇所讲解的栈和队列属于逻辑结构上的划分。逻辑结构分为线性结构、非线性结构 线性结构：有且仅有一个开始节点和一个终端节点，每个节点最多只有一个直接前驱和一个直接后继。代表结构：栈、队列 非线性结构：一个节点可能有多个直接前驱和多个直接后继。代表结构：树、图 堆栈（英语：stack）又称为栈或堆叠，是计算机科学中的一种抽象数据类型，只允许在有序的线性数据集合的一端（称
C++实现数据结构——顺序栈和链栈
m0_37433111的博客
08-08 567
2020年8月8日 周六 天气晴 【不悲叹过去，不荒废现在，不惧怕未来】 本文目录1. 引言2. 主文件——main.cpp3. 顺序栈类.h文件——sqstack.h4. 链栈类.h文件——linkstack.h5. 预编译头文件——stdafx.h参考文献 1. 引言 用C++实现了简单的顺序栈和链栈类，成员函数实现了栈的基础功能：isEmpty()，push()，pop()，top()，并且用实现的栈解决了两个问题：进制转换和判断表达式是否有效，代码是用VS2019实现的，每个函数的功能都添加了一
算法与数据结构——顺序栈和链式栈
weixin_45579386的博客
11-15 234
顺序栈采用地址连续的存储空间（数组)依次存储栈中数据元素，入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的.栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置。 顺序栈的各种代码如下: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define TYPE int 创建栈 typedef struct Stackorder { TYPE* ptr
栈——顺序栈和链式栈
2301_80261854的博客
03-31 652
作为一种数据结构，是一种只能在同一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）也就是后进先出（LIFO）或者先进后出。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。
数据结构——顺序栈与链式栈的实现
wei_Embedded_z的博客
01-02 1487
数据结构——顺序栈与链式栈的实现 概念 接口 栈的基本运算顺序栈 (Sequential Stack) 实 栈的链表实现 两种实现的优缺点
数据结构——顺序栈详解
weixin_51785373的博客
10-20 1915
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
数据结构——顺序栈【c语言版】
clear-ninghongkang的博客
11-20 4889
栈（stack）是一种只能在一端插入或删除操作的线性表。 栈的主要特点：LIFO(last in first out) "后进先出" 栈可以采用顺序存储结构(顺序栈)和链式存储结构(链式栈) 假设栈的元素个数最大不超过正整数MAXSIZE，所以元素具有同一数据类型（ElemType），用下来方式来声明顺序栈的类型SQStack： #define MAXSIZE 128 typedef int ElemType; typedef struct { ElemType data[M...
数据结构——顺序栈
潮与虎
10-28 585
栈，从数据结构的方向来看，它属于线性表先进后出、后进先出的原则。
C语言实现数据结构——顺序栈与链栈
chfens的博客
04-02 2133
C语言实现顺序栈与链栈的基本功能。
数据结构实验——栈子系统
07-31
在本实验中，我们主要探讨的是数据结构中的一个重要概念——栈（Stack），并采用C语言进行实现。栈是一种特殊的线性表，具有“后进先出”（LIFO，Last In First Out）的特性，其操作主要集中在一端，称为栈顶。在...
数据结构说课稿——栈.pdf
08-07
顺序存储栈通常使用数组来实现，而链式存储栈则使用链表数据结构。在实现栈时，需要设计数据类型来表示栈元素及其操作，这在高级编程语言中通常通过封装来完成。 在计算机科学和软件工程领域，栈的算法设计思想被...
一本通数据结构——栈的习题，很全，希望您能喜欢
08-10
《一本通数据结构——栈的习题》可能涵盖了栈的各种基础和进阶问题，旨在帮助学习者深入理解栈的原理和应用。通过这些习题，你可以掌握以下知识点： 1. **栈的基本操作**：了解栈的两个基本操作，即入栈（Push）和...
第三章 栈和队列 顺序存储结构和链式存储结构
04-20
本章将深入探讨两种重要的数据结构——栈和队列，以及它们的两种常见存储方式：顺序存储结构和链式存储结构。 栈（Stack）被称为“后进先出”（Last In, First Out，简称LIFO）的数据结构。栈的操作主要围绕两个...
作业 第三章 栈和队列 顺序存储结构和链式存储结构
04-20
本章主要探讨的是两种常用且基础的数据结构——栈（Stack）和队列（Queue），以及它们的两种基本存储方式：顺序存储结构（Sequential Storage Structure）和链式存储结构（Linked Storage Structure）。我们将深入...
数据结构之---堆（2）
2301_81684056的博客
08-15 634
出堆是指将堆顶数据出堆。出堆完成后要保证剩余数据还是满足原来堆的性质。所以我们把堆顶数据和堆底最后一个数据交换，取出新堆底数据，之后通过向下调整算法将剩下的数据重新排列成一个堆。大堆经过出堆操作得出的数据是升序的小堆经过出堆操作得出的数据是降序的。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 912
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 574
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
数据结构——时间复杂度和空间复杂度
2301_80373479的博客
08-15 927
带你了解时间复杂度和空间复杂度
C语言实现括号匹配：顺序栈与链式栈
该资源主要介绍了如何使用C语言实现顺序栈和链栈的数据结构，并通过一个具体的例子——括号匹配，来展示栈的应用。内容包括实验目的、顺序栈的定义、基本操作的实现以及链栈的实现。 1. 实验目标： - 学生需要掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值