栈类实现与括号匹配问题（c++）

1，关于栈

堆栈 又名栈（stack），它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

可以发现，最先进入栈的E是最后出去，最后进来的A第一个出去，就像一端封口的羽毛球筒，只能通过一端来拿放羽毛球。第一个放进去的羽毛球之能是最后一个拿出来。故名先进后出原则FILO（first in last out）

在c++的STL标准库中提供了几个常用的栈函数：

push(eleType ele);	//添加元素
pop();				//删除元素
size();				//获取栈大小
isempty();			//判断栈是否为空
top();				//返回栈顶元素
.....

2.自定义栈类

首先，建立一个栈类，三个私有成员，ele，size，top分别用来存放元素，表示大小，栈顶置针。并且写了构造函数与析构函数，最后初始化常用的几个函数：

class Stacks{
private:
	eleType *ele;
	int size;
	eleType top;
public:
	Stacks() : ele(nullptr),size(0),top(-1) {}
	~Stacks() { delete [] ele; }
	void initStack(int capacity);//初始化
	bool push(eleType element); //添加
	bool pop(); //弹出
	bool isEmpty(); //是否为空
	eleType getTop(); //栈顶元素
};

初始化函数实现，首先检查ele是否分配了内存，如果有，就执行删除，没有就为ele分配一个新的内存。

void Stacks::initStack(int capacity){
	if(ele) {
		delete[]  ele;
	}
	ele =  new int[capacity];
	size = capacity;
}

添加，删除函数实现，添加时先对栈进行判断，如果栈满，跑出异常，否则top指针++，将插入的值传入ele。删除函数实现先判断栈是否为空，为空抛出异常，之后top–；

//添加
bool Stacks::push(eleType element){
	if (size - 1 == top){
		throw out_of_range("Stack is full!");
	}
	top++;
	ele[top] = element;
	return true;
}
//删除
bool Stacks::pop(){
	if(isEmpty()){
		throw out_of_range("Stack is empty!");
	}
	top--;
	return true;
}

判空函数，栈顶元素实现：

//是否为空
bool Stacks::isEmpty(){
	return top == -1;
}
//返回栈顶元素
eleType Stacks::getTop(){
	if(!isEmpty()) return ele[top];
	else throw out_of_range("Stack is empty!");
}

完整程序与主函数调用：

#include <iostream>
#include<stdexcept>
using namespace std;
#define eleType int

class Stacks{
private:
	eleType *ele;
	int size;
	eleType top;
public:
	Stacks() : ele(nullptr),size(0),top(-1) {}
	~Stacks() { delete [] ele; }
	void initStack(int capacity);//初始化
	bool push(eleType element); //添加
	bool pop(); //弹出
	bool isEmpty(); //是否为空
	eleType getTop(); //栈顶元素
};
//初始化
void Stacks::initStack(int capacity){
	if(ele) {
		delete[]  ele;
	}
	ele =  new int[capacity];
	size = capacity;
}
//添加
bool Stacks::push(eleType element){
	if (size - 1 == top){
		throw out_of_range("Stack is full!");
	}
	top++;
	ele[top] = element;
	return true;
}
//删除
bool Stacks::pop(){
	if(isEmpty()){
		throw out_of_range("Stack is empty!");
	}
	top--;
	return true;
}
//是否为空
bool Stacks::isEmpty(){
	return top == -1;
}
//返回栈顶元素
eleType Stacks::getTop(){
	if(!isEmpty()) return ele[top];
	else throw out_of_range("Stack is empty!");
}
int main() {
	Stacks s;
	s.initStack(10);
	s.push(4);
	s.push(5);
	s.push(6);
	int n1 = s.getTop();
	s.pop();
	int n2 = s.getTop();
	s.pop();
	cout<<n1 + n2;
}

3.括号匹配问题

括号匹配问题是一个在计算机科学和编程中常见的问题。主要是检查一个字符串中的括号是否正确配对，即每一个打开的括号（如“(”、“{”、“[”）都有一个相对应的关闭括号（如“)”、“}”、“]”），并且它们的顺序是正确的。

我们可以用上面的栈来解决问题。以下是解决括号匹配问题的算法步骤：

• 1.初始化一个空栈：用于存储尚未匹配的开放括号。
• 2.遍历输入字符串：逐个检查字符。
• 3.遇到开放括号：将其压入栈中。
• 4.遇到关闭括号：检查栈顶元素是否是与该关闭括号匹配的开放括号。如果是，则将栈顶元素弹出；如果不是或栈为空，则括号不匹配。
• 5.遍历结束后检查栈：如果栈为空，说明所有括号都正确匹配；如果栈不为空，说明还有未匹配的开放括号，因此括号不匹配。

函数实现：

bool isMatching(char *str,int len){
	Stacks s;
	s.initStack(100);
	for(int i=0;i<len;i++){
		if(str[i] == '(' || str[i] == '[' || str[i] == '{'){
			s.push(str[i]);
		}
		if(str[i]==')'){
			if(s.getTop() != '(' || s.isEmpty()) return false;
			s.pop();
		}
		if(str[i]==']'){
			if(s.getTop() != '[' || s.isEmpty()) return false;
			s.pop();
		}
		if(str[i]=='}'){
			if(s.getTop() != '{' || s.isEmpty()) return false;
			s.pop();
		}
	}
	return s.isEmpty();
}

完整程序：

#include <iostream>
#include<stdexcept>
using namespace std;
#define eleType char

class Stacks{
private:
	eleType *ele;
	int size;
	eleType top;
public:
	Stacks() : ele(nullptr),size(0),top(-1) {}
	~Stacks() { delete [] ele; }
	void initStack(int capacity);//初始化
	bool push(eleType element); //添加
	bool pop(); //弹出
	bool isEmpty(); //是否为空
	eleType getTop(); //栈顶元素
};
//初始化
void Stacks::initStack(int capacity){
	if(ele) {
		delete[]  ele;
	}
	ele =  new eleType[capacity];
	size = capacity;
}
//添加
bool Stacks::push(eleType element){
	if (size - 1 == top){
		throw out_of_range("Stack is full!");
	}
	top++;
	ele[top] = element;
	return true;
}
//删除
bool Stacks::pop(){
	if(isEmpty()){
		throw out_of_range("Stack is empty!");
	}
	top--;
	return true;
}
//是否为空
bool Stacks::isEmpty(){
	return top == -1;
}
//返回栈顶元素
eleType Stacks::getTop(){
	if(!isEmpty()) return ele[top];
	else throw out_of_range("Stack is empty!");
}
bool isMatching(char *str,int len){
	Stacks s;
	s.initStack(100);
	for(int i=0;i<len;i++){
		if(str[i] == '(' || str[i] == '[' || str[i] == '{'){
			s.push(str[i]);
		}
		if(str[i]==')'){
			if(s.getTop() != '(' || s.isEmpty()) return false;
			s.pop();
		}
		if(str[i]==']'){
			if(s.getTop() != '[' || s.isEmpty()) return false;
			s.pop();
		}

		if(str[i]=='}'){
			if(s.getTop() != '{' || s.isEmpty()) return false;
			s.pop();
		}
	}
	return s.isEmpty();
}
int main() {
	char str[] = "(){}[}";
	int len  = strlen(str);
	cout<<isMatching(str, len);
}

如有错误，欢迎指正！