【数据结构】栈

最新推荐文章于 2025-09-07 21:51:48 发布
原创 最新推荐文章于 2025-09-07 21:51:48 发布 · 619 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #开发语言

目录

1 栈

（1）概念与结构

（2）栈的实现（数组）

定义栈的结构

1 初始化

2 销毁

3 入栈

判断栈是否为空

4 出栈

5 取栈顶元素

 6 获取栈的有效个数

（3）栈的应用

1 栈

（1）概念与结构

栈：⼀种特殊的线性表，其只允许在固定的⼀端进⾏插⼊和删除元素操作。进⾏数据插⼊和删除操作 的⼀端称为栈顶，另⼀端称为栈底。栈中的数据元素遵守后进先出LIFO（LastInFirstOut）的原则。

压栈：栈的插⼊操作叫做进栈/压栈/⼊栈，⼊数据在栈顶。

 出栈：栈的删除操作叫做出栈。出数据也在栈顶。

LIFO:后进先出或者说先进后出

对于栈的理解图如下：

用数组来实现栈：入栈和出栈的时间复杂度都是O（1）

栈的结构：

逻辑结构：是线性的；

物理结构：不一定，取决于你是用数组实现的还是用链表实现的，如果是用数组实现的，数组是连续存放，元素地址都是连续的，此时是线性结构，用链表实现则不是线性结构。

（2）栈的实现（数组）

定义栈的结构
​//定义栈的结构
typedef int STDataType;
typedef struct Stack
{
 STDataType* arr;
 int top;//定义栈中有效数据的个数
 int capacity;//栈的空间大小
 }ST；

​
1 初始化

（1）List.h:

#pragma once
#include<stdio.h>
#include<stdlib.h>
 
typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	STDataType size;//定义栈中有效的数据个数
	STDataType capacity;//栈的空间大小
}ST;
 
//初始化
void STInit(ST* ps);

(2)List.c

#define  _CRT_SECURE_NO_WARNINGS  1
 
#include"Stack.h"
 
//初始化
void STInit(ST* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

(3)test.c

#define  _CRT_SECURE_NO_WARNINGS  1
 
#include"Stack.h"
 
void test01()
{
	ST st;
	STInit(&st);
}
 
int main()
{
	test01();
	return 0;
}
2 销毁
​//销毁
void STDesTroy(ST* ps)
{
 if(ps->arr)
   free(ps->arr);

 ps->arr = NULL:
 ps->top = ps->capacity = 0;
}

​

​
3 入栈

有两种情况：1）栈内空间大小足够

                      2）栈内空间不够-------增容

栈顶插入数据，栈顶对于数组来说就是数组的尾部，栈顶插入数据即在数组尾部插入数据。

List.c

//入栈——栈顶
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	//判断空间是否足够
	if (ps->top == ps->capacity)
	{
		//增容
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		int* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
	//空间足够
	ps->arr[ps->top++] = x;
}

test.c

#define  _CRT_SECURE_NO_WARNINGS  1
 
#include"Stack.h"
 
void test01()
{
	ST st;
	STInit(&st);
	STPush(&st, 1);
	STPush(&st, 2);
	STPush(&st, 3);
	STPush(&st, 4);
 
	STDestory(&st);
}
 
int main()
{
	test01();
	return 0;
}
判断栈是否为空
//栈是否为空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
4 出栈

//出栈——栈顶
void STPop(ST* ps)
{
	assert(!STEmpty(ps));
	ps->top--;
}

5 取栈顶元素

top指向的是有效数据的下一个位置，取栈顶是top-1

//获取栈中有效元素个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
 6 获取栈的有效个数
​
int STSize(ST* ps)//用int 是因为明确了返回的数据是int类型，而不是栈中定义的int类型
{
 assert(ps);
 return ps->top;
}

​

（3）栈的应用

思路：借助数据结构-----栈，遍历字符串，左括号入栈，是右括号就取栈顶元素比较，看是否匹配

注意:是取栈顶，不是出栈顶！！！

  1. 数据结构选择：使用栈存储左括号（(、[、{），因为括号匹配需要遵循 "最晚出现的左括号最先被匹配" 的规则，与栈的特性一致。

  2. 遍历字符串：

    • 遇到左括号时，将其压入栈中（STPush）。
    • 遇到右括号时：
      • 若栈为空（无对应的左括号），直接返回无效（false）。
      • 取出栈顶的左括号，检查是否与当前右括号匹配（如(对应)）。
      • 若不匹配，返回无效；若匹配，将该左括号出栈（STPop）。

  3. 最终判断：

    • 遍历结束后，若栈为空，说明所有左括号都找到了匹配的右括号，返回有效（true）。
    • 若栈不为空，说明存在未匹配的左括号，返回无效（false）。

  4. 边界处理：

    • 每次操作前验证栈的状态（非空判断），避免空指针访问。
    • 函数结束前销毁栈（STDesTroy），释放内存，防止泄露。
​
//定义栈的结构
typedef char STDataType;
typedef struct Stack {
	STDataType* arr;
	int top; //指向栈顶的位置---刚好就是栈中有效数据个数
	int capacity;//栈的空间大小
}ST;

//初始化
void STInit(ST* ps)
{
	ps->arr = NULL;
	ps->top = ps->capacity = 0;

}

//销毁
void STDesTroy(ST* ps)
{
	if(ps->arr)
		free(ps->arr);

	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}

//入栈——栈顶
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	//判断空间是否足够
	if (ps->top == ps->capacity)
	{
		//增容
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail！");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
	//空间足够
	ps->arr[ps->top++] = x;
}
//栈是否为空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
//出栈———栈顶
void STPop(ST* ps)
{
	assert(!STEmpty(ps));
	ps->top--;
}

//取栈顶元素
STDataType STTop(ST* ps)
{
	assert(!STEmpty(ps));
	return ps->arr[ps->top - 1];
}

//获取栈中有效元素个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}



----------------------以上是对栈的实现和应用-----------------------------------
bool isValid(char* s)
{
 //借助数据结构---栈
 ST st;
 STInit(&st);
 char* pi = s;
 while(*pi != '\0')
 {
  //左括号入栈
  if(*pi == '(' || *pi == '[' || *pi == '{')
  {
   STPush(&st,*pi);//入栈
   }
  else
  {
   //右括号---取栈顶，比较，如果匹配则出栈，不匹配则直接返回false
   //栈不为空才能取栈顶
     if(STEmpyt(&st));
       {
         STDesTroy(&st)):
         return false;
        }
      char top = STTop(&st);
      if((top == '(' && *pi != ')') || (top == '[' && *pi != ']') ||(top == '{' && *pi != '}')
      {
        STDesTroy(&st);
        return false;
      }
     //本次是匹配---出栈
     STPop(&st);
    }
  pi++;
 }

//判断栈是否为空，为空有效，非空无效
//用三姆操作符判断是否为空
bool ret = STEmpy(&st) ? true  :false;
STDesTroy(&st);
return ret;

​

时间复杂度：O（N）  空间复杂度：O（1）

栈的全部代码如下：

（1）LIst.h:

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
 
typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int top;//定义栈中有效的数据个数
	int capacity;//栈的空间大小
}ST;
 
//初始化
void STInit(ST* ps);
 
//销毁
void STDestory(ST* ps);
 
//入栈——栈顶
void STPush(ST* ps, STDataType x);
 
//出栈——栈顶
void STPop(ST* ps);
 
//取栈顶元素
STDataType STTop(ST* ps);
 
//栈是否为空
bool STEmpty(ST* ps);
 
//获取栈中有效元素个数
int STSize(ST* ps);

(2)List.c

#define  _CRT_SECURE_NO_WARNINGS  1
 
#include"Stack.h"
 
//初始化
void STInit(ST* ps)
{
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}
 
//销毁
void STDestory(ST* ps)
{
	if (ps->arr)
		free(ps->arr);
 
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}
 
//入栈——栈顶
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	//判断空间是否足够
	if (ps->top == ps->capacity)
	{
		//增容
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		int* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
	//空间足够
	ps->arr[ps->top++] = x;
}
 
//栈是否为空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
 
//出栈——栈顶
void STPop(ST* ps)
{
	assert(!STEmpty(ps));
	ps->top--;
}
 
//取栈顶元素
STDataType STTop(ST* ps)
{
	assert(!STEmpty(ps));
	return ps->arr[ps->top - 1];
}
 
//获取栈中有效元素个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

(3)test.c

#define  _CRT_SECURE_NO_WARNINGS  1
 
#include"Stack.h"
 
void test01()
{
	ST st;
	STInit(&st);
	STPush(&st, 1);
	STPush(&st, 2);
	STPush(&st, 3);
	STPush(&st, 4);
 
	printf("size:%d\n", STSize(&st));
 
	//STPop(&st);
	while (!STEmpty(&st))
	{
		//取栈顶
		STDataType top = STTop(&st);
		printf("%d ", top);
		//出栈
		STPop(&st);
	}
	printf("\n");
	STDestory(&st);
}
 
int main()
{
	test01();
	return 0;
}

zzzsde
关注
数据结构——栈的详解
晴空๓
04-20 8万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 29万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C++数据结构——栈
GeekZW的博客
06-25 17万+
C++数据结构——栈 最近计划再复习一遍数据结构，看到一篇博客：https://www.cnblogs.com/QG-whz/p/5170418.html#_label0。 1、栈(Stack)是一种线性存储结构，它具有如下特点： ...
【数据结构】栈和队列
小羊的博客
07-12 3494
栈超超超详解
数据结构——栈
Eristic0618的博客
01-03 1882
本篇文章围绕数据结构中的栈展开详细讲解，内容包含栈的概念和接口实现以及栈的OJ题讲解
数据结构之栈
jiaomubai的博客
01-30 3037
什么是栈 栈是一种常用的数据结构，其数据存储使用的是逻辑结构。逻辑结构是一个比较抽象的概念，它依赖于物理结构而存在。逻辑结构又分为线性结构和非线性结构。比如顺序表表、栈和队列等就是典型的线性结构，而树和图等就是非线性结构。 栈（Stack）是一种线性数据结构，它就像一个单通道的容器，其中的元素只能先进后出（First In Last Out，简称 FILO）。由于其是单通道的，所以决定了最早进入容器的元素只能最晚出。最早进入的元素存放的位置叫做栈底，最后进入的元素存放的位置叫做栈顶。像栈这种线性结构既可
数据结构--栈
weixin_62008675的博客
09-05 2856
一些，顺序栈是通过指针指向假设的栈顶，其他元素其实依然存在，但链栈的栈顶之前的元素会被垃圾回收，因此链栈的实现综合时间和空间来看，更优秀一些。对比链栈和顺序栈的实现，可以发现入栈和出战方法的时间复杂度都是O(1)，效率上没有区别，但是顺序栈占用的空间会相对更多。顺序栈底层是数组，最大空间容量受到限制，因此必须初始化一个数组的容量，也就是栈的容量，链栈则无需此操作。常见的栈实现方式有数组和链表两种，其中数组实现的栈又称为顺序栈，链表实现的栈称为链式栈。（Bottom）：固定的，不允许进行插入和删除的另一端。
数据结构之——栈
WenJieya的博客
03-27 7333
数据结构之——栈 一：栈的定义： 栈是限定是限定仅在表位进行插入和删除操作的线性表，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。 栈顶：允许插入和删除的一端称为栈顶。 栈底：不可以进行插入和删除操作。 空栈：不含任何数据元素的栈称为空栈。 理解栈的定义需要注意几点： 1：它是一个线性表，即说明栈元素具有 线性关系，即 前驱后继 关系。只不 过它是一种特殊的线性表而已。 2：定义中说在线性表的表的表尾进行插入和删除操作，注意这里表尾指的是
数据结构 栈 入栈 输出 出栈
shangxianjiao的博客
05-16 5146
数据结构 栈 入栈 输出 出栈 #include<bits/stdc++.h> /* #include<iostream> #include<> */ using namespace std; //pA->p(Next)=pB->p(top)含义是pA指向pB typedef struct Node//有节点的数据类型 { int data;//数据域 struct Node * pNext; }NODE,*PNODE; typedef str
C语言 数据结构 栈的顺序表示和实现
C语言/数据结构/数学建模/深度学习/生物信息
01-12 3494
栈的顺序表示和实现 文章目录1 顺序栈结构2 基本操作函数3 整体代码test3.cStack.h4 运行结果5 附加题 栈的存储结构可以是顺序表或链表，该篇为顺序表存储 栈是后进先出的数据结构 1 顺序栈结构 栈结构体 top永远指向下一个 typedef struct Stack { DataType data[maxn]; // 作为栈元素的存储方式，数据类型为DataType int top; // top即栈顶指
数据结构栈的实验报告.doc
07-11
实验报告的主题是关于数据结构中的顺序栈的基本操作，主要涵盖了栈的初始化、进栈、出栈等核心概念。顺序栈是一种特殊的线性表，它的特点是只允许在一端进行插入和删除操作，这一端称为栈顶。 1. **栈的类型定义**...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
长沙理工大学数据结构栈的实现与应用算术表达式求值实验报告.doc
09-29
数据结构栈的实现与应用算术表达式求值实验报告 一、实验环境 在本实验中，我们使用了 32 位操作系统下的 Window 平台，并使用 Microsoft Visual C++ 作为开发环境。 二、实验目的 掌握栈的实现及使用，并应用于...
数据结构面试心得超详细重点知识点总结 数据结构栈与队列.docx
10-21
数据结构 数据结构知识点总结 章节目录 1.数据结构的一般概念 2.线性表 3.栈与队列 4.树结构 5.图结构 6.排序与查找 7.如何学习数据结构 一、数据结构的一般概念 重点详细内容知识点总结： 数据：所有能被输入到...
Redis之核心数据结构浅析
qq_44784918的博客
09-05 988
Redis基础命令与数据结构摘要 Redis支持多种数据结构，命令不区分大小写但key区分： String：单值操作(set/get)、多值(mset/mget)、分布式锁(setnx/expire)、计数器(incr) Hash：存储对象(hset/hgetall)，适合购物车场景，节省空间但无法field级过期 List：双端队列(lpush/rpop)，可用于消息队列 Set：去重集合(sadd/smembers)，适合抽奖、点赞等场景 Zset：有序集合(zadd/zrange)，带score排序，
数据结构：哈希（Hashing）
2402_88047672的博客
09-02 1635
本文介绍了哈希表的基本原理和实现方法。哈希表通过哈希函数将键（Key）映射到数组下标（Index），以实现快速查找。理想情况下应使用完美哈希函数避免冲突，但现实中难以实现。文章重点讲解了两种冲突解决方法：开放定址法（线性探测）和拉链法。开放定址法容易产生聚集问题，而拉链法通过链表处理冲突，性能更稳定。最后指出拉链法是工业界最常用的方法，只要哈希函数设计合理，查询效率可接近O(1)。
数据结构之二叉树（2）
2401_86945837的博客
09-07 579
int size;}Hp;size表示有效个数capacity表示可用容量。
【数据结构基础习题】-1- 数据结构基本操作
最新发布
2401_83117850的博客
09-07 693
int *data;// 存储数据的数组int front;// 队头指针int rear;// 队尾指针// 数组容量int size;// 队列中元素个数。
嵌入式中关于数据结构的简单认识
嵌入式技术开发
09-07 15
摘要：数据结构是计算机存储和组织数据的方式，分为逻辑结构和物理结构。逻辑结构包括线性、非线性（树形、图形）和集合结构；物理结构包含顺序、链式、索引和散列存储。算法是解决问题的步骤，具有有穷性、确定性、可行性等特征。评估算法的优劣主要看时间复杂度和空间复杂度：时间复杂度反映语句执行次数（如O(n)），空间复杂度衡量内存占用。两者常相互制约，需根据需求选择平衡。好的算法应兼顾效率、可读性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值