数据结构：栈

最新推荐文章于 2024-10-01 23:10:03 发布

Pianeers

最新推荐文章于 2024-10-01 23:10:03 发布

阅读量808

点赞数 50

分类专栏：初阶数据结构文章标签：数据结构 java 开发语言

本文链接：https://blog.csdn.net/2402_82667241/article/details/139062372

版权

初阶数据结构专栏收录该内容

4 篇文章 3 订阅

订阅专栏

前言：

在日常生活中我们经常遇到这种情况如：打手枪，你的子弹夹，先装进弹夹的子弹，最后被打出来。为什么会有这种情况呢？

这正与我们今天要讲的栈有关

一、栈的基本概念

1.栈的概念及结构

栈（stack）：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。

栈顶（top）：进行数据插入和删除操作的一端

栈底（bottom）：固定的，不允许进行插入和删除的一端

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

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

栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

2.栈的存储结构

由栈的定义可知栈是一种特殊的线性表，又因为线性表的存储结构为顺序存储结构和链式存储结构，所以栈的存储结构也分两种：

相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小

3.栈的基本操作

① 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); 获取数据个数

二、栈的顺序存储结构

1.栈的顺序存储分析

栈的顺序存储结构是指使用数组来实现栈数据结构。具体实现方式是定义一个固定大小的数组，然后使用一个指针来指示栈顶元素的位置。栈顶指针指向栈顶元素的下一位置，栈中的元素依次排列在数组中。

若存储栈的长度为StackSize，则栈顶位置top的取值可以小于StackSize，也可以等于StackSize：

①top初始值==0时，top指向栈顶数据的下一个位置。

②top初始值==-1时，top指向栈顶数据。

2.栈的顺序存储的实现

2.1栈的顺序存储结构的描述

#define MAXSIZE 50  //定义栈中元素的最大个数
typedef int STDataType;   //STDataType的类型根据实际情况而定，这里假定为int
typedef struct{
    STDataType data[MAXSIZE];
    int top;    //用于栈顶指针
}ST;

2.2顺序栈的初始化

void STInit(ST*pst){
    pst->top = -1;    //初始化栈顶指针，在这里我们使用-1举例子
}

2.3顺序栈的判空

bool STEmpty(ST* pst){
    if(pst->top == -1){    
        return true;    //栈空
    }else{  
        return false;   //不空
    }
}

2.4顺序栈的进栈

void STPush(ST* pst, STDataType x)
{
 //如果栈满
 if(pst->top+1==MAXSIZE)
 {
   return error;
 }
 //如果栈不满
 pst->top++;   //栈顶指针增加一
 pst->data[pst->top] = x;    //将新插入元素赋值给栈顶空间
}

2.5顺序栈的出栈

void STPop(ST* pst)
{
  //如果栈已经为空了
  if(pst->top==-1)
  {
   return error;
  }
  //如果栈不为空
  S->top--;
}

2.6读取栈顶数据

STDataType STTop(ST* pst)
{
    if(S->top == -1){   //栈空
        return ERROR;
    }
    return pst->data[pst->top];
}

三、栈的链式存储结构

1.栈的链式存储结构的描述

栈的链式存储结构是使用链表来存储栈元素的一种方式，在链式存储结构中，每个栈元素被存储在一个节点中，节点中包含了该元素的值以及指向下一个节点的指针。

具体来说，链式存储结构中栈的顶部元素是链表的头节点，而栈底元素是链表的尾节点。每当压入一个元素时，创建一个新的节点，并将该节点插入到链表的头部。当弹出一个元素时，删除链表的头节点，并返回该节点的值。

2.栈顶链式存储的实现

2.1链栈的结构

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;//栈的空间大小
}ST;

2.2链栈的初始化

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

	pst->a = NULL;
	// top指向栈顶数据的下一个位置
	pst->top = 0;//这里我们用这个top值

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

	pst->capacity = 0;
}

2.3链栈的入栈

void STPush(ST* pst, STDataType x)
{
	assert(pst);

	// 如果栈为空或栈已经满了，进行扩容
	if (pst->top == pst->capacity)
	{
       //如果栈为0则先为4个整形，栈为满则变为原来两倍
		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++;
}

2.4链栈的出栈

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

	pst->top--;
}

2.5取栈顶元素

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

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

2.6链栈的判空

bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;
}

2.7链表栈获取数据个数

int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

2.8链表栈的销毁

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

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

四、链表的两种存储结构的比较

顺序存储：

优点：操作简单、效率高；

缺点：容量固定，无法动态扩展，当栈满时无法继续插入元素。

链式存储：

优点：可以动态地扩展栈的大小，而不受固定大小的限制；

缺点：比于顺序存储结构，链式存储结构需要更多的内存空间来存储节点的指针。另外，链式存储结构的访问时间复杂度较高，因为需要遍历链表才能找到栈顶元素。

五、栈的运用——括号匹配问题

这道题的要求是：

①左括号必须用相同类型的右括号闭合。

②左括号必须以正确的顺序闭合。

③右括号前边必须是对应的左括号才有效，否则无效

这时候我们可以借用栈的运用，从左往右我们可以使用栈，遇左括号就压入栈，如果遇到右括号弹出栈顶，两者对应则抵消，如果不匹配则字符串无效

注意：

该字符串长度一定为偶数，并且最后栈内还有元素的话则字符串无效

bool isValid(char * s)
{
    char str[10000];
    int i,j;
    int len = strlen(s);
    int count=0;
    if(len%2==1)  //括号总数为奇数
    {
        return false;
    }
    for(i=0;i<len;i++)
    {
        if(s[i]=='('||s[i]=='['||s[i]=='{')  //遇到左括号进栈
        {
            str[count++]=s[i];
        }
        else if(i>0)   
        {
            if(count==0)  //栈为空
                return false;
            else if((s[i]==')'&&str[count-1]=='(')||(s[i]==']'&&str[count-1]=='[')||(s[i]=='}'&&str[count-1]=='{'))  //匹配到出栈
            {
                count--;
            }
            else  //匹配不到结束
            {
                return false;
            }
        }
    }
    if(count==0)
        return true;
    else
        return false;
}