容器适配器-stack栈

C++标准库不只是包含了顺序容器，还包含一些为满足特殊需求而设计的容器，它们提供简单的接口。

这些容器可被归类为容器适配器(container adapter)，它们是改造别的标准顺序容器，使之满足特殊需求的新容器。

适配器:也称配置器,把一种接口转为另一种接口。

有三种标准的容器适配器: stack(栈)、queue(队列)和priority queue(优先级队列)。 priority queue就是“根据排序准则，自动将元素排序”的队列，其所谓“下一个””元素总是拥有最高优先级。

stack栈

stack 栈是一种只在一端(栈顶)进行数据插入(入栈)和删除(出栈)的数据结构,它满足后进先出(LIFO)的特性。

使用push(入栈)将数据放入stack,使用pop(出栈)将元素从容器中移除。 POP PUSH栈顶TOP栈底

使用stack,必须包含头文件:

#include <stack>

在头文件中,class stack定义如下:

namespace std{
    template <typename T,
    typename Container = deque<T>>
    class stack;
}

第一个参数T代表类型,第二个参数用来定义stack内部存放数据的容器,默认为deque。之所以选择deque而非vector,是因为deque移除数据时可能会释放内存,并在插入数据需要扩容时不需要复制所有的数据。

例如，以下定义了一个元素类型为整数的 stack:

std::stack<int> st;

stack 只是很单纯地把各项操作转化为内部容器对应的函数调用。你可以使用任何支持 back()、push_back()和pop_back()成员函数的标准容器支持 stack。例如你可以使用 vector或list 来存放数据:

stack<int,vector<int>> st;//整型栈,使用vector存放数据

注意:forword_list和array不可以作为其容器

定义及初始化

#include <iostream>
#include <stack>
#include <vector>
#include <list>
using namespace std;

int main()
{
    stack <char> s1;//创建一个默认的栈,最常用

    stack <char, deque<char> > s2;//显示创建用deque保存数据的栈,和s1等价

    stack <int, vector<int> > s3;//创建用vector保存数据的栈

    stack <int, list<int> > s4;//创建用list保存数据的栈

    return 0;
}

先创建一个空的栈,然后往里面存放数据。

常用操作

stack栈的操作比较简单,不支持迭代器和运算符,只有几个简单的成员函数。 empty成员函数

empty成员函数

判断栈是否为空。

//判空
bool IsEmpty(PLStack ps)
{
	return ps->next == NULL;
}

pop成员函数

出栈函数,删除栈顶元素。

//获取栈顶元素的值,并且删除
bool Pop(PLStack ps, int* rtval)
{
	assert(ps != NULL);
	if (ps == NULL)
		return false;

	if (IsEmpty(ps))
		return false;

	*rtval = ps->next->date;

	LSNode* p = ps->next;
	ps->next = ps->next->next;
	free(p);
	return true;
}

push成员函数

入栈函数,往栈顶添加数据。

//往栈中入数据(入栈操作)
bool Push(PLStack ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
		return false;

	LSNode* p = (LSNode*)malloc(sizeof(LSNode));
	assert(p != NULL);
	p->date = val;
	p->next = ps->next;
	ps->next = p;
	return false;
}

size成员函数

返回栈的数据个数。

//获取栈中有效数据的个数
int GetLength(PLStack ps)
{
	assert(ps != NULL);
	if (ps == NULL)
		return 0;

	int count = 0;
	for (LSNode* p = ps->next; p != NULL; p = p->next)
	{
		count++;
	}
	return count;
}

top成员函数

返回栈顶元素的引用。

//获取栈顶元素的值,但不删除
bool  GetTop(PLStack ps, int* rtval)
{
	assert(ps != NULL);
	if (ps == NULL)
		return false;

	if (IsEmpty(ps))
		return false;

	*rtval = ps->next->date;
	return true;
}

栈的实现方式

链表实现：链表实现栈则更加灵活，它不需要预先分配固定大小的内存空间，适用于栈的大小动态变化且难以预估的场景。在链表实现中，每个节点包含数据和指向下一个节点的指针。栈顶对应链表的头节点，入栈和出栈操作都在链表头部进行，时间复杂度同样为 O (1)。

.h文件

#pragma once

//链式栈
typedef struct LSNode
{
	int date;
	struct LSNode* next;
}LSNode, * PLStack;

//初始化
void InitStack(PLStack ps);

//往栈中入数据(入栈操作)
bool Push(PLStack ps, int val);

//获取栈顶元素的值,但不删除
bool  GetTop(PLStack ps, int* rtval);

//获取栈顶元素的值,并且删除
bool Pop(PLStack ps, int* rtval);

//判空
bool IsEmpty(PLStack ps);

//获取栈中有效数据的个数
int GetLength(PLStack ps);

//清空所有的数据
void Clear(PLStack ps);

//销毁
void Destroy(PLStack ps);

.cpp文件

#include "Istak.h"
#include <iostream>
#include <cassert>
using namespace std;

//初始化
void InitStack(PLStack ps)
{
	assert(ps != NULL);
	if (ps == NULL)
		return;

	ps->next = NULL;
}

//往栈中入数据(入栈操作)
bool Push(PLStack ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
		return false;

	LSNode* p = (LSNode*)malloc(sizeof(LSNode));
	assert(p != NULL);
	p->date = val;
	p->next = ps->next;
	ps->next = p;
	return false;
}

//获取栈顶元素的值,但不删除
bool  GetTop(PLStack ps, int* rtval)
{
	assert(ps != NULL);
	if (ps == NULL)
		return false;

	if (IsEmpty(ps))
		return false;

	*rtval = ps->next->date;
	return true;
}

//获取栈顶元素的值,并且删除
bool Pop(PLStack ps, int* rtval)
{
	assert(ps != NULL);
	if (ps == NULL)
		return false;

	if (IsEmpty(ps))
		return false;

	*rtval = ps->next->date;

	LSNode* p = ps->next;
	ps->next = ps->next->next;
	free(p);
	return true;
}

//判空
bool IsEmpty(PLStack ps)
{
	return ps->next == NULL;
}

//获取栈中有效数据的个数
int GetLength(PLStack ps)
{
	assert(ps != NULL);
	if (ps == NULL)
		return 0;

	int count = 0;
	for (LSNode* p = ps->next; p != NULL; p = p->next)
	{
		count++;
	}
	return count;
}

//清空所有的数据
void Clear(PLStack ps)
{
	Destroy(ps);
}

//销毁
void Destroy(PLStack ps)
{
	LSNode* p;
	while (ps->next != NULL)
	{
		p = ps->next;
		ps->next = p->next;
		free(p);
	}
}

栈的应用场景

1.表达式求值

在数学表达式求值中，栈发挥着关键作用。例如，对于后缀表达式（逆波兰表达式），我们可以利用栈来高效地计算结果。后缀表达式将运算符放在操作数之后，避免了括号带来的优先级判断复杂性。计算时，从左到右扫描后缀表达式，遇到操作数就将其入栈，遇到运算符则从栈中弹出相应数量的操作数进行运算，并将结果入栈。最终，栈顶元素即为表达式的计算结果。以表达式 “3 4 + 2 *” 为例，计算过程如下：

扫描到 3，入栈，栈：[3]

扫描到 4，入栈，栈：[3, 4]

扫描到 +，弹出 4 和 3，计算 3 + 4 = 7，将 7 入栈，栈：[7]

扫描到 2，入栈，栈：[7, 2]

扫描到 *，弹出 2 和 7，计算 7 * 2 = 14，将 14 入栈，栈：[14]

最终结果为 14

2.括号匹配

在编译器和文本编辑器中，常常需要检查代码中的括号是否正确匹配，如圆括号、方括号和花括号。利用栈可以轻松解决这个问题。当遇到左括号时，将其入栈；遇到右括号时，从栈中弹出对应的左括号进行匹配。如果在匹配过程中栈为空或者匹配失败，说明括号不匹配。例如，对于字符串 “{[()]}”，处理过程如下：

遇到 {，入栈，栈：[{]

遇到 [，入栈，栈：[{, []

遇到 (，入栈，栈：[{, [, (]

遇到 )，弹出 (进行匹配，栈：[{, []

遇到 ]，弹出 [进行匹配，栈：[{]

遇到 }，弹出 {进行匹配，栈：[]

匹配成功

3.函数调用栈

在程序执行过程中，函数调用是通过栈来管理的。当一个函数被调用时，它的相关信息，如参数、局部变量和返回地址等，会被压入栈中。当函数执行完毕返回时，这些信息会从栈中弹出，程序继续执行调用函数的下一条指令。例如，在一个包含多个函数嵌套调用的程序中，栈记录了函数调用的顺序和状态，确保函数能够正确返回和继续执行。假设函数 A 调用函数 B，函数 B 又调用函数 C，栈的状态变化如下：

调用 A，A 的相关信息入栈，栈：[A]

A 中调用 B，B 的相关信息入栈，栈：[A, B]

B 中调用 C，C 的相关信息入栈，栈：[A, B, C]

C 执行完毕返回，C 的信息出栈，栈：[A, B]

B 执行完毕返回，B 的信息出栈，栈：[A]

A 执行完毕返回，A 的信息出栈，栈：[]

4.深度优先搜索（DFS）

在图论和搜索算法中，深度优先搜索常常用栈来实现。在遍历图的过程中，从起始节点开始，将其入栈。然后，每次从栈中弹出一个节点，访问该节点，并将其未访问过的邻接节点入栈，直到栈为空。这样的方式使得搜索沿着一条路径尽可能深地探索下去，直到无法继续，然后回溯到上一个节点继续探索其他路径。

5.浏览器历史记录

我们日常使用的浏览器，其历史记录功能也运用了栈的思想。当我们依次访问网页 A、B、C 时，这些网页依次被压入栈中。当我们点击 “后退” 按钮时，就相当于执行出栈操作，从栈顶弹出当前页面，回到上一个页面。例如，访问顺序为 A -> B -> C，栈的状态为 [C, B, A]，点击 “后退”，C 出栈，回到 B 页面，栈变为 [B, A]

总结

栈作为一种简单而强大的数据结构，以其独特的后进先出特性，在众多领域展现出高效的应用价值。无论是复杂的算法实现，还是日常使用的软件功能，栈都默默发挥着重要作用。通过对栈的概念、操作、实现方式以及应用场景的深入学习，我们不仅掌握了一种基础的数据结构，更能在编程实践中灵活运用它来解决各种实际问题。在未来的编程之旅中，希望你能充分利用栈的优势，优化代码，提升程序的性能和效率。让我们继续探索数据结构的奇妙世界，解锁更多编程的奥秘！