数据结构之栈

已于 2022-04-08 15:29:16 修改
阅读量2.6k 收藏 10
点赞数 12
分类专栏： 【数据结构学习】 文章标签： 数据结构 c语言
于 2022-04-08 15:26:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53010164/article/details/124017271
版权

目录

一、栈

（1）栈的概念：

 （2）压栈及出栈

（3）栈的实现

 (4)牛刀小试：

(5)初始化top初始值的俩种情况

二、代码实现

(1)初始化

(2)入栈

(3)删除栈顶数据​

(4)获取栈顶元素

(5)检测是否为空

(6)获取栈中有效元素

(7)遍历栈中元素

（8）销毁栈

总代码：

三、有效的括号

一、栈

（1）栈的概念：

是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。
进行数据插入和删除的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出或者先进后出的原则。

如图：

 （2）压栈及出栈

压栈：栈的插入操作叫做进栈、压栈或者入栈，从栈顶压入数据
出栈：栈的删除操作叫做出栈。出数据也在栈顶

如图 进栈：

 如图 出栈：

（3）栈的实现

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

 如图 链栈：

 (4)牛刀小试：

1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出 栈的顺序是（ ）。

A 12345ABCDE      B EDCBA54321    C ABCDE12345    D 54321EDCBA

解析：B :   因为是一次入栈，在依次出栈，栈遵循着后进先出的原则，所以出栈的顺序为

EDCBA54321

2.若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）

A 1,4,3,2         B 2,3,4,1       C 3,1,4,2       D 3,4,2,1

解析：C:  因为进栈的顺序为1234，进栈过程中可以出栈

选项A：1进，然后出，2,3在栈中，4进，出，3出，2出，所以正确
选项B:   1进，2进，出，3进，出，4进，出，最后1出，正确
选项C： 1进，2进，3进，出，栈中还剩1和2，而栈是先进后出的原则，先出1错误，因为栈顶指针指向的是2，不能先出1
选项D：1进，2进，3进，出，4进，出，2出，1出，正确

(5)初始化top初始值的俩种情况

二、代码实现

(1)初始化
 

//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;//ps->top = -1;
	ps->capacity = 0;
}

(2)入栈

//入栈
void StackPush(ST* ps, DataType x)
{
	assert(ps);
	//考虑如果容量不够的情况
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		DataType* tmp =realloc(ps->a,newcapacity * sizeof(DataType));//a是一个指针，每次访问4个字节，第一次扩了4个 4字节
		if (tmp == NULL)
		{
			printf("realloc failed");
			exit(-1);
		}
		//更新
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

(3)删除栈顶数据

//删除栈顶数据
//因为我们每次访问的是ps->a[top-1]的位置，所以top--访问的是当前top的下一个位置，也就相当于top当前所指向的位置的值被删除了
void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);//top == 1 表示,容量为1,栈顶指针指向0，top == 0表示容量为0，栈顶指针为-1，栈为NULL
	ps->top--;
}

(4)获取栈顶元素

//获取栈顶元素
DataType StackTop(ST* ps)
{
	assert(ps);
	//方式一：
	/*assert(ps->top > 0);*/
	//方式二：
	assert(!StackEmpty(ps));
	return ps->a[ps->top-1];
}

(5)检测是否为空

//检测栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	//写法一：
	//if (ps->top == 0)
	//{
	//	return true;
	//}
	//else
	//	return false;
	//写法二：
	return ps->top == 0;//top == 0，为1，表示栈为空
}

(6)获取栈中有效元素

//获取栈中有效元素
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;//top为1，容量为1，如栈顶指向0，top指向他的上一个，也就是1，此时容量为1
}

(7)遍历栈中元素

//遍历栈
void StackPrint(ST* ps)
{
	//遍历栈
	while (!StackEmpty(ps))//栈不为空
	{
		printf("%d ", StackTop(ps));
		//删除栈顶元素，top--,也就是先将栈顶元素出栈，然后top--，访问下一个
		StackPop(ps);
	}
}

效果图：

（8）销毁栈

//销毁栈
void StackDestroy(ST* ps) 
{
	//将数组的指针释放掉即可
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

总代码：

stack.h

#pragma once
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;
typedef struct Stack
{
	DataType* a;//a相当于一个数组
	int top;
	int capacity;
}ST;

//初始化
void StackInit(ST* ps);
//销毁栈
void StackDestroy(ST* ps);
//入栈
void StackPush(ST* ps,DataType x);
//出栈
void StackPop(ST* ps);
//获取栈顶元素
DataType StackTop(ST* ps);
//获取栈中有效元素
int StackSize(ST* ps);
//检测栈是否为空
bool StackEmpty(ST* ps);
//遍历栈
void StackPrint(ST* ps);

stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"stack.h"
//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;//ps->top = -1;
	ps->capacity = 0;
}
//入栈
void StackPush(ST* ps, DataType x)
{
	assert(ps);
	//考虑如果容量不够的情况
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		DataType* tmp =realloc(ps->a,newcapacity * sizeof(DataType));//就是a是一指针，每次访问4个字节，第一次扩了4个 4字节
		if (tmp == NULL)
		{
			printf("realloc failed");
			exit(-1);
		}
		//更新
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//销毁栈
void StackDestroy(ST* ps) 
{
	//将数组的指针释放掉即可
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
//删除数据
void StackPop(ST* ps)
{
	assert(ps);
	//写法一：
	/*assert(ps->top > 0);*///top == 1 表示,容量为1,栈顶指针指向0，top == 0表示容量为0，栈顶指针为-1，栈为NULL
	//写法二：
	assert(!StackEmpty(ps));
	ps->top--;
}
//获取栈顶元素
DataType StackTop(ST* ps)
{
	assert(ps);
	//方式一：
	/*assert(ps->top > 0);*/
	//方式二：
	assert(!StackEmpty(ps));
	return ps->a[ps->top-1];
}
//检测栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	//写法一：
	//if (ps->top == 0)
	//{
	//	return true;
	//}
	//else
	//	return false;
	//写法二：
	return ps->top == 0;//top == 0，为1，表示栈为空
}
//获取栈中有效元素
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;//top为1，容量为1，如栈顶指向0，top指向他的上一个，也就是1，此时容量为1
}

//遍历栈
void StackPrint(ST* ps)
{
	//遍历栈
	while (!StackEmpty(ps))//栈不为空
	{
		printf("%d ", StackTop(ps));
		//删除栈顶元素，top--,也就是先将栈顶元素出栈，然后top--，访问下一个
		StackPop(ps);
	}
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"stack.h"

void stacktest()
{
	ST s1;
	StackInit(&s1);

	StackPush(&s1,1);
	StackPush(&s1,2);
	StackPush(&s1,3);

	StackPop(&s1);
	StackPop(&s1);
	//StackPop(&s1);
	int a = StackSize(&s1);
	printf("%d\n",a);

	printf("%d",StackTop(&s1));
	StackDestroy(&s1);
}

void stacktest1()
{
	ST s2;
	StackInit(&s2);

	StackPush(&s2, 1);
	StackPush(&s2, 2);
	StackPush(&s2, 3);
	printf("%d ", StackTop(&s2));
	StackPop(&s2);
	StackPush(&s2,4);
	StackPush(&s2,5);

	StackPrint(&s2);//遍历栈

	StackDestroy(&s2);
}

int main()
{
	/*stacktest();*/
	stacktest1();

	return 0;
}

三、有效的括号

20. 有效的括号 - 力扣（LeetCode） (leetcode-cn.com)

 因为C语言不能直接使用栈，所以要先创建出栈及栈的相关操作：

#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;
typedef struct Stack
{
	DataType* a;//a相当于一个数组
	int top;
	int capacity;
}ST;

//初始化
void StackInit(ST* ps);
//销毁栈
void StackDestroy(ST* ps);
//入栈
void StackPush(ST* ps,DataType x);
//出栈
void StackPop(ST* ps);
//获取栈顶元素
DataType StackTop(ST* ps);
//获取栈中有效元素
int StackSize(ST* ps);
//检测栈是否为空
bool StackEmpty(ST* ps);
//遍历栈
void StackPrint(ST* ps);
#define _CRT_SECURE_NO_WARNINGS 1

//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;//ps->top = -1;
	ps->capacity = 0;
}
//入栈
void StackPush(ST* ps, DataType x)
{
	assert(ps);
	//考虑如果容量不够的情况
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		DataType* tmp =realloc(ps->a,newcapacity * sizeof(DataType));//就是a是一指针，每次访问4个字节，第一次扩了4个 4字节
		if (tmp == NULL)
		{
			printf("realloc failed");
			exit(-1);
		}
		//更新
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//销毁栈
void StackDestroy(ST* ps) 
{
	//将数组的指针释放掉即可
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
//删除数据
void StackPop(ST* ps)
{
	assert(ps);
	//写法一：
	/*assert(ps->top > 0);*///top == 1 表示,容量为1,栈顶指针指向0，top == 0表示容量为0，栈顶指针为-1，栈为NULL
	//写法二：
	assert(!StackEmpty(ps));
	ps->top--;
}
//获取栈顶元素
DataType StackTop(ST* ps)
{
	assert(ps);
	//方式一：
	/*assert(ps->top > 0);*/
	//方式二：
	assert(!StackEmpty(ps));
	return ps->a[ps->top-1];
}
//检测栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	//写法一：
	//if (ps->top == 0)
	//{
	//	return true;
	//}
	//else
	//	return false;
	//写法二：
	return ps->top == 0;//top == 0，为1，表示栈为空
}
//获取栈中有效元素
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;//top为1，容量为1，如栈顶指向0，top指向他的上一个，也就是1，此时容量为1
}

//遍历栈
void StackPrint(ST* ps)
{
	//遍历栈
	while (!StackEmpty(ps))//栈不为空
	{
		printf("%d ", StackTop(ps));
		//删除栈顶元素，top--,也就是先将栈顶元素出栈，然后top--，访问下一个
		StackPop(ps);
	}
}
bool isValid(char * s)
{
    ST s1;
    StackInit(&s1);
    while(*s)//不等于'\0'
    {
        if(*s == '{' || *s == '[' || *s == '(')
        {
            StackPush(&s1,*s);
            ++s;
        }
        else//是右括号,那么就那么就将栈中的拿出来比较，匹配，s++,继续循环，不匹配，则返回false
        {
            //特殊情况1：
            //如果栈为空，只有]
            if(StackEmpty(&s1))
            {
               StackDestroy(&s1);
               return false;
            }
           DataType top =  StackTop(&s1);
           StackPop(&s1);//删除栈顶元素
           if( (*s == '}' && top != '{' )
           ||(*s == ']' && top != '[' )
           || (*s == ')' && top != '('))
           {
               //如果是 ()(  ] ]
               StackDestroy(&s1);//只要return之前就Destroy，防止内存泄漏
               return false;
           }
           else
           {
               ++s;
           }
        }
    }
    //特殊情况2:
    //如果只有[,那说明栈不是空,与之不匹配，返回0
    bool ret = StackEmpty(&s1);
    StackDestroy(&s1);
    return ret;
}

运行结果：

 本文是我对栈的学习的一些笔记以及自己的一些理解，如有问题，请在评论区多多评论^_^

@@永恒
关注
  • 12
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
数据结构-栈的基本操作（初始化，判空，求长度，取栈顶元素，进栈，出栈，遍历，销毁）（详细注解）
qq_62630363的博客
11-22 1165
数据结构-栈的基本操作（初始化，判空，求长度，取栈顶元素，进栈，出栈，遍历，销毁）（详细注解）
C语言实现栈和队列
qq_49613557的博客
04-22 803
C语言实现栈和队列 目录栈队列栈和队列完整代码实现 栈 1.栈 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在顶。 1.2栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小
C++ STL中使用push和pop在栈顶插入和删除元素
最新发布
qq_41317716的博客
04-29 273
C++ STL中使用push和pop在栈顶插入和删除元素
数据结构：顺序栈的操作（创建、销毁、入栈、出栈、取栈顶元素）
ml29895063的博客
06-24 1613
顺序栈的操作（创建、销毁、入栈、出栈、取栈顶元素）
栈 入栈 出栈 获取栈顶元素
绿色水杯
03-28 4053
#include<stdio.h> #include<stdlib.h> #define OK 1 #define OVERFLOW -2 #define FALSE 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef int Status; typedef float SElemType; typedef struct { SElemType *base; SElemType *top; int
【数据结构】顺序栈和链栈的基本操作（定义，初始化， 入栈，出栈，取栈顶元素，遍历，置空）
小吉妙妙屋
04-12 1万+
详细讲解顺序栈和链栈的初始化，入栈，出栈，取栈顶元素，遍历，置空等操作
Java数据结构之栈的基本定义与实现方法示例
08-29
Java数据结构之栈的基本定义与实现方法示例 Java数据结构之栈是一种特殊的线性表，它只能在某一端插入和删除元素，按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶...
数据结构-使用javascript讲解数据结构之栈结构.zip
02-12
在这个“数据结构-使用javascript讲解数据结构之栈结构.zip”文件中，我们可以通过JavaScript语言来深入理解栈的原理和应用。 首先，栈是一种线性数据结构，其操作主要集中在一端，称为栈顶。栈的基本操作包括入栈...
C语言数据结构之栈简单操作
01-01
C语言数据结构之栈简单操作 实验： 编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能： （1）初始化顺序栈 （2）插入元素 （3）删除栈顶元素 （4）取栈顶元素 （5）遍历顺序栈 ...
数据结构之栈和队列 基本的增删查改
04-03
数据结构之栈和队列 基本的增删查改。栈（Stack）和队列（Queue）是数据结构中常用的两种基本数据结构。栈是一种后进先出（Last In First Out, LIFO）的数据结构，只允许在栈顶进行插入和删除操作；而队列是一种先进...
数据结构之栈的定义及实现
09-29
在这个主题中，“数据结构之栈的定义及实现”将深入探讨栈的基本概念、操作以及在编程中的具体实现。 栈的定义： 栈是一种线性数据结构，它的特点是元素只能在栈的一端进行插入和删除操作，这一端被称为栈顶。新...
用类来实现简单的栈。栈中有以下操作：元素入栈，读出栈顶元素值，退栈，判断栈顶空否，如果溢出，程序终止。
05-04
栈中有以下操作：元素入栈，读出栈顶元素值，退栈，判断栈顶空否，如果溢出，程序终止。
数据结构——栈（stack）
wry_sunny_的博客
03-16 674
一、顺序栈 栈（stack）是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它...
数据结构之栈的简单应用（入栈 出栈 取栈顶元素 求栈的长度）
weixin_30640291的博客
03-22 1152
//将123456依次入栈，将45出栈，再将67进栈最后全部出栈依次输出 #include<iostream>#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define maxsize 100using namespace std;typedef struct node{ int...
【数据结构】栈的基本操作
Bonstoppo
07-23 444
操作包含：栈的定义，Push，Pop，判空，栈顶元素。
数据结构：栈C语言实现
weixin_51885188的博客
11-08 1569
目录 栈的概念及结构 栈的实现 栈的初始化 栈的销毁 压栈 出栈 返回栈顶的元素 统计栈中的元素个数 判断栈是否为空 栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一段进行插入和删除元素操作。进行数据插入和删除操作的一段被称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 它这个结构有点类似于子弹的弹夹，我们.
栈——栈的定义及基本操作（初始化、判空、进栈、出栈、遍历栈、销毁栈等）
热门推荐
薛定谔的猫的博客
04-19 8万+
文章目录栈的定义栈的存储栈上的基本操作初始化判空操作进栈操作出栈操作读栈顶元素遍历栈销毁栈完整代码及实例共享栈 栈的定义 栈（Stack）是只允许在一端进行插入或删除操作的线性表。 栈的示意图： 栈顶Top：线性表允许插入和删除的那一端。 栈底Bottom：固定的，不允许进行插入和删除的另一端。  假设某个栈S={a1,a2, … ,an}，如上图所示，则a1为栈底元素，an为栈顶元素。由于只能在栈顶进行插入和删除操作，故进栈顺序为a1,a2, … ,an，出栈顺序为an, … ,a2,a1。故栈的操
【数据结构】栈的详解
fighting小泽的博客
05-17 2867
栈的结构体其实和顺序表差不多，一个动态开辟的数组，一个栈的容量。注意 top 我们要决定它指向栈顶还是栈顶的下一个元素。如果top初始化为0，则它指向栈顶的下一个元素。如果top初始化为-1，则它指向栈顶元素。我比较喜欢初始化为0，1是top还可以表示元素的个数，可以用来判断栈是否满了。2是插入元素的时候直接在top的位置插入就行，然后再top++即可。这里根据大家喜好设定就行。int top;} ST;
栈的两种遍历方式
qq_19925065的博客
09-11 9407
一、普通遍历 public void test05(){ MyLinkedStack<String> myStack = new MyLinkedStack<String>(); myStack.push("1"); myStack.push("2"); myStack.push("3"); myStack.pus

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值