数据结构初阶——栈

最新推荐文章于 2024-07-25 11:43:17 发布

zhh601

最新推荐文章于 2024-07-25 11:43:17 发布

阅读量149

点赞数

分类专栏：数据结构 LeetCode 文章标签：数据结构链表

本文链接：https://blog.csdn.net/weixin_45138295/article/details/127772738

版权

数据结构同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

LeetCode

5 篇文章 0 订阅

订阅专栏

之前的文章中我们讲述了双向带头循环链表的实现，在这篇文章中，我们会讲解栈的实现。

栈

栈的概念及结构

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

栈的实现

栈实现的简要介绍

栈可以通过我们执勤的文章中介绍过的单链表或者是顺序表实现，但是因为栈只有入栈与出栈这两个跟数据存储有关的基本操作。在设计单链表或者是顺序表的时候我们就需要注意一些问题。

我们知道单链表的头插非常的方便，因此若是要选用单链表作为栈实现的数据结构，那么我们就需要使用头插的方式。相对于动态顺序表而言，动态顺序表访问会更加的快捷因为它在内存中是连续的存储，在本文中，选用的就是动态顺序表实现流程。

动态增长的栈的结构体定义

//假定栈中存储的数据类型为int
typedef int STDataType;

//定义初始化时的容量
#define DEFAULTY_CAPACITY 4

//支持动态增长的栈
typedef struct Stack
{
	STDataType* _data;
	//栈的容量
	int _capacity;
	//栈顶的下标
	int _top;
}Stack;

栈的初始化

void StackInit(Stack* ps)
{
	assert(ps);
	将指向数组的指令置零
	//ps->_data = NULL;
	将容量设为0
	//ps->_capacity = 0;
	将栈顶设为0位置
	//ps->_top = 0;

	STDataType* tmp = (STDataType*)malloc(sizeof(STDataType) * DEFAULTY_CAPACITY);
	if (tmp == NULL)//初始化之后一定要对其进行判断操作
	{
		perror("malloc failed");
		exit(-1);
	}
	ps->_data = tmp;
	ps->_top = 0;
	ps->_capacity = DEFAULTY_CAPACITY;

    //这两种方法都可以进行初始化操作
    //区别就是在入栈操作的时候代码会有区别
}

在初始化的时候还有这一个关键性的问题就是_top的值我们该设计为多少。若是使用的top = -1，那么在进行入栈操作的时候就就需要先执行top++操作，再对栈中的数据进行赋值。若是top = 0，那么就需要我们先进行赋值操作，然后再top++。这个初始化值还会影响到后面其他的函数实现。在这里使用的是top = 0。

入栈

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->_data, ps->_capacity*2*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}
		ps->_data = tmp;
		ps->_capacity *= 2;
	}
	ps->_data[ps->_top] = x;
	ps->_top++;
}

出栈

void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	ps->_top--; 
}

出栈时有一点需要我们注意，那就是当栈顶的标志top等于0时，是不可以再进行出栈操作的，因此在这里需要我们进行断言，防止出错。

返回栈顶元素

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top >= 0);
	return ps->_data[ps->_top-1];
}

在这里就需要注意，前文中top的值得问题，会对栈顶的位置产生影响。

返回栈的长度

int StackSize(Stack* ps)
{
	assert(ps);
	assert(ps->_top >= 0);
	return ps->_top;
}

判断栈是否为空

bool StackEmpty(Stack* ps)
{
	return ps->_top == 0;
}

销毁栈

void StackDestroy(Stack* ps)
{
	free(ps->_data);
	ps->_data = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

栈基本功能的测试

//test.c
#include "Stack.h"

void TestStack01()
{
	Stack s;
	StackInit(&s);
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	StackPush(&s, 5);

	StackPop(&s);
	StackPop(&s);
	StackPop(&s);
	StackPop(&s);
	StackPop(&s);
	//StackPop(&s);//err
}

int main()
{
	TestStack01();
	return 0;
}

附件

//Stack.h
#pragma once

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

//假定栈中存储的数据类型为int
typedef int STDataType;

//定义初始化时的容量
#define DEFAULTY_CAPACITY 4

//支持动态增长的栈
typedef struct Stack
{
	STDataType* _data;
	//栈的容量
	int _capacity;
	//栈顶的下标
	int _top;
}Stack;

//栈的初始化
void StackInit(Stack* ps);

//入栈
void StackPush(Stack* ps, STDataType x);

// 出栈 
void StackPop(Stack* ps);

// 获取栈顶元素 
STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数 
int StackSize(Stack* ps);

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps);

// 销毁栈 
void StackDestroy(Stack* ps);

//Stack.c
#include "Stack.h"

void StackInit(Stack* ps)
{
	assert(ps);
	将指向数组的指令置零
	//ps->_data = NULL;
	将容量设为0
	//ps->_capacity = 0;
	将栈顶设为0位置
	//ps->_top = 0;

	STDataType* tmp = (STDataType*)malloc(sizeof(STDataType) * DEFAULTY_CAPACITY);
	if (tmp == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	ps->_data = tmp;
	ps->_top = 0;
	ps->_capacity = DEFAULTY_CAPACITY;
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->_data, ps->_capacity*2*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}
		ps->_data = tmp;
		ps->_capacity *= 2;
	}
	ps->_data[ps->_top] = x;
	ps->_top++;
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	ps->_top--; 
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top >= 0);
	return ps->_data[ps->_top-1];
}

int StackSize(Stack* ps)
{
	assert(ps);
	assert(ps->_top >= 0);
	return ps->_top;
}

bool StackEmpty(Stack* ps)
{
	return ps->_top == 0;
}

void StackDestroy(Stack* ps)
{
	free(ps->_data);
	ps->_data = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

介绍一道可以用栈解决的题目

20. 有效的括号https://leetcode.cn/problems/valid-parentheses/

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

在这个题目中正好可以使用刚刚我们编写的栈来进行解题，当字符串没有到结束标志'\0'时，我们若是遇到一个'('或'{'或'['就将其入栈，接着重复上述操作直至读到的不是左符号，然后再出栈与后面一个字符进行匹配，若是正好可以结合就继续循环，若是不匹配就直接跳出循环。需要注意的问题有这些：

若是遇到了'('，出循环的时候栈就不是空的；
若是遇到了')'，在循环内部的时候栈也是空的；
我们不能直接在末尾的return处进行free操作，因为在函数执行的时候可能会在之前就跳出函数，因此我们需要将每一个return后面都加上free。

//假定栈中存储的数据类型为int
typedef char STDataType;

//支持动态增长的栈
typedef struct Stack
{
	STDataType* _data;
	//栈的容量
	int _capacity;
	//栈顶的下标
	int _top;
}Stack;

void StackInit(Stack* ps)
{
    assert(ps);
	STDataType* tmp = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (tmp == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	ps->_data = tmp;
	ps->_top = 0;
	ps->_capacity = 4;
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->_data, ps->_capacity*2*sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}
		ps->_data = tmp;
		ps->_capacity *= 2;
	}
	ps->_data[ps->_top] = x;
	ps->_top++;
}

bool StackEmpty(Stack* ps)
{
    assert(ps);
	return ps->_top == 0;
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->_top--; 
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->_data[ps->_top-1];
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}



void StackDestroy(Stack* ps)
{
    assert(ps);
	free(ps->_data);
	ps->_data = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}


bool isValid(char * s){
    Stack sta;
    StackInit(&sta);
    while (*s)
    {
        if (*s == '(' || *s == '[' || *s == '{')
        {
            StackPush(&sta, *s);
            ++s;
        }
        else
        {
            if (StackEmpty(&sta))
            {
                StackDestroy(&sta);
                return false;
            }
            char top = StackTop(&sta);
            StackPop(&sta);
            if ((*s == ')' && top != '(')
                ||(*s == ']' && top != '[')
                ||(*s == '}' && top != '{'))
            {
                StackDestroy(&sta);
                return false;
            }
            else
            {
                ++s;
            }
        }      
    }
    bool ret = StackEmpty(&sta);
    StackDestroy(&sta);
    return ret;
}