简单数据结构——栈和队列1(栈超全）（初始化，销毁，出栈入栈销毁实现，例题运用）

XSTIT

于 2024-05-09 11:36:54 发布

阅读量1.1k

点赞数 34

分类专栏： c语言栈和队列文章标签：数据结构 c++ c语言开发语言算法

本文链接：https://blog.csdn.net/XSTIT/article/details/138524630

版权

c语言同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

栈和队列

1 篇文章 0 订阅

订阅专栏

知识特点

类似数据表链表，在逻辑上依次存储，但对比顺序表和链表有所限制，不能随便存储

一定要先掌握顺序表的实现，本人博客有顺序表专栏大家可以自行查看，看懂顺序表专栏之后再来了解栈的实现会更容易懂。

如果还没有掌握顺序表可以先收藏本篇文章再进行查看本篇内容。

1.栈

1.1栈的概念和结构

一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除的一端叫做栈顶，另一端叫做栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

删除数据：出栈

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

类比：羽毛球桶和弹夹（后压进去的先出来）

单链表/双链表都可以实现栈

2.栈的实现

2.1选择实现方式

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小

首先不选择双链表:对比单链表还有2倍指针，不宜维护，更加复杂化了

数组实现栈缺点：插入数据不够了需要扩容，自身有消耗，但是开辟空见释放空间调用速度很快，所以影响不大

数组实现栈优点：cpu高速缓存速率很快

数组和单链表相差不大，我们选择数组来实现

2.2栈的实现创建头文件

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



typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//用size也可以，两者都行
	int capacity;
}ST;
//初始化和销毁
void STInit(ST* pst);
void STDestroy(ST* pst);


//实现插入，不用分头插尾插，因为只能从栈顶插入
void STPush(ST*pst,STDataType x);
void STPop(ST* pst);//取栈顶数据


//形参需要传过来指针，否则实现完初始化之后无法传回去
//这一部分在结构体里又讲（大家可以去看侧栏合集）
// 

//  获取栈顶数据
STDataType STTop(ST* pst);


//提供两个接口
bool STEmpty(ST* pst);//判断栈是否为空

//获取栈里面的数据个数
int STSize(ST* pst);

vs中实现图：

2.3栈的实现创建源文件

2.3.1需要注意top（为什么pst->top=-1;)

1.top到底是只想哪里呢？（top指向栈顶数据，但是有两个方法表示）

指向栈顶还是指向栈顶的下一个元素呢？

其实是根据自己的定义来的

法一：（top指向栈顶元素）
若想要top直接指向栈顶元素，那么初始化的时候top就不能为0

因为top如果为0就无法清楚此时到底是有元素还是没有元素（存在误导）。

所以top一开始初始化就应该指向-1，这样top指向0的时候就可以表示为指向了第一个元素，类似于数组，第一个元素下标为0，第二个元素下标为1；（top指向栈顶元素）

法二：（top指向栈顶下一个元素）

如果top指向了栈顶，直接指向0，那么说明第一个元素指向了1；

（类比size的用法就可）

注意：两种方式都可以，但是前后需要匹配

若pst->top=0;说明top指向栈顶数据的下一个位置。

若pst->top=-1;说明top指向栈顶数据。

一定要区分清楚!!!!!!(用数组设计栈的关键点）

不能误认为top初始化为0并且top还指向栈顶元素。

选择一个方式就行（我们选择初始化为0的方式，也就是说指向栈顶元素的下一个元素，而不是栈顶元素）

2.3.2为什么不能直接用结构体引用而是要用函数呢？

是否可以用直接自行访问数据?

（建议还是要规范运用函数调用而不是自己调用，很容易出错）

2.3.3实现

#include"Stack.h"
void STInit(ST* pst)
{
	assert(pst);//首先需要断言传过来的不能是空指针
	//然后开始对方法中的每一个成员变量初始化
	pst->a = NULL;
	pst->top = 0;//（已经讲解）
	pst->capacity = 0;
}
//摧毁
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);//free掉之后记得要置为空
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}


//入栈出栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);//实 现的第一步都是先进行断言
	//当top==capacity时说明容量已经满了，此时需要扩容
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
			//如果没有开辟成功就直接报错
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity; 
	}
	pst->a[pst->top] = x;
	pst->top++;//存入数据之后top需要+1
}   
//出栈
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--; 
}  
//取栈顶数据
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top>0);
	return pst->a[pst->top - 1];//返回
}


bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top==0;//因为top指向的是栈顶的后面一个元素，因此如果是返回0的话说明该栈为空，没有任何元素；
}//这里是判断真假

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;//我们是用法二来定义top的,所以top的使用与size类似，因此，数据个数可以直接返回top就可以计算出来
}

3.栈的例题（括号匹配）

题目：

解答：

//利用栈的思想来解题
//在c语言中首先要创建一个栈
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef char STDataType;//因为是字符

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

// 初始化和销毁
void STInit(ST* pst);
void STDestroy(ST* pst);

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

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

// 判空
bool STEmpty(ST* pst);
// 获取数据个数
int STSize(ST* pst);

// 初始化和销毁
void STInit(ST* pst)
{
   assert(pst);

   pst->a = NULL;
   // top指向栈顶数据的下一个位置
   pst->top = 0;

   // top指向栈顶数据
   //pst->top = -1;

   pst->capacity = 0;
}

void STDestroy(ST* pst)
{
   assert(pst);

   free(pst->a);
   pst->a = NULL;
   pst->top = pst->capacity = 0;
}

// 入栈出栈
void STPush(ST* pst, STDataType x)
{
   assert(pst);

   // 扩容
   if (pst->top == pst->capacity)
   {
       int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
       STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
       if (tmp == NULL)
       {
           perror("realloc fail");
           return;
       }

       pst->a = tmp;
       pst->capacity = newcapacity;
   }

   pst->a[pst->top] = x;
   pst->top++;
}

void STPop(ST* pst)
{
   assert(pst);
   assert(pst->top > 0);

   pst->top--;
}

// 取栈顶数据
STDataType STTop(ST* pst)
{
   assert(pst);
   assert(pst->top > 0);

   return pst->a[pst->top - 1];
}

// 判空
bool STEmpty(ST* pst)
{
   assert(pst);

   return pst->top == 0;
}

// 获取数据个数
int STSize(ST* pst)
{
   assert(pst);

   return pst->top;
}

bool isValid(char* s)
{
   //新建一个成员变量st
   ST st;
   STInt(&st);
   while (*s)//如果是\0就直接结束了
   {
       //如果是左括号就入栈
       if (*s == '(' || *s == '[' || *s == '{')
       {
           STPush(&st, *s);//入栈
       }
       else//右括号取栈顶左括号尝试匹配
       {
           char top = STTop(&st);
           STPop(&st);//取出一个，删除一个方便取出
           //如果判断匹配，那如果匹配还要再进行下一个比对，因此可以直接判断不匹配的情况
           if ((top == '(' && *s != ')') || (top == '[' && *s != ']')
               || (top == '{' && *s != '}'))
           {
               STDestroy(&st);
               return false;
           }
       }
       ++s;
   }
   //不用栈记得销毁,避免内存泄漏

   //栈不为空，说明左括号比右括号多，数量不匹配
   bool ret = STEmpty(&st);
   STDestroy(&st);
   return ret;
}