算符优先分析法

最新推荐文章于 2024-11-09 20:38:27 发布
最新推荐文章于 2024-11-09 20:38:27 发布
阅读量723 收藏 15
点赞数 22
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64514056/article/details/135123895
版权
  • 实验目的
  1. 加深对语法分析器工作过程的理解;
  2. 加强对算符优先分析法实现语法分析程序的掌握;
  3. 能够釆用一种编程语言实现算符优先分析法总控程序;
  • 实验预备知识 
  1. 进一步理解算符文法的定义、优先关系的含义及求解方法。
  2. 掌握算符优先分析法的一般结构和过程。 
    #include <fstream>
#include<iostream>
#include<string>
#include<vector>
#include<set>
#include<unordered_map>
#include<stack>
#include <iomanip>
using namespace std;

typedef string  variable;//变量
typedef string  terminal;//终结符
typedef string  start;//开始符号

typedef struct production//产生式
{
	string left;
	vector<string> right;//将右部的产生式按照每一个变量和每一个终结符分割放入右部数组
}proudction;

typedef struct grammar
{
	set<variable> V;//变量集合
	set<terminal> T;//终结符集合
	vector<production> P;//产生式
	start S;//开始符号
	unordered_map<variable, set<terminal>>FIRSTOP;//FIRST集合
	unordered_map<variable, set<terminal>>LASTOP;//FLLOW集合
}grammar;

unordered_map<terminal, unordered_map<terminal, string>>Priority_Relationship_Matrix;//优先关系矩阵

int split(vector<production>& pro, string s)//分割字符串取出产生式左部和右部
{
	production p;
	int i = 0;
	int spLR = -1;
	for (i; i < s.size() - 1; i++)
	{
		if (s[i] == '-' && s[i + 1] == '>')
		{
			spLR = i;
			break;
		}
	}
	if (i == 0 || i >= s.size())
	{
		cout << endl << "这个产生式" << s << "错误！！！请重新输入";
		return -1;
	}
	p.left = s.substr(0, i);
	s.erase(0, i + 2);

	p.right.push_back("");
	for (i = 0; i < s.size(); i++)
	{
		if (s[i] == '|')
		{
			if (p.right[0].size() == 0)
			{
				p.right[0] = "$";
			}
			pro.push_back(p);
			p.right[0] = "";
		}
		else
		{
			p.right[0] = p.right[0] + s[i];
		}
	}
	if (p.right[0].size() == 0)
	{
		p.right[0] = "$";
	}
	pro.push_back(p);
	return 0;
}

int getV_PR_S(grammar& G)//获得文法的变量，获得开始符号，以一个变量和一个终结符为单位分割产生式的右部
{
	G.S = G.P[0].left;//获得开始符号
	for (int i = 0; i < G.P.size(); i++)//获得变量
	{
		G.V.insert(G.P[i].left);
	}
	//以单一变量或者终结符为单位分割产生式右部
	for (int i = 0; i < G.P.size(); i++)
	{
		string s = G.P[i].right[0];//获得此时的产生式
		G.P[i].right.clear();//清空产生式右部分
		if (s == "$")//如果此时的产生式本身就是空的话把$加入右部之后直接进入下一次循环
		{
			G.P[i].right.push_back("$");
			continue;
		}
		int flag = 0;
		while (flag != 1)
		{
			flag = 1;
			int x = s.size();
			for (auto j = G.V.begin(); j != G.V.end(); j++)//先用变量集合去匹配
			{
				string v = *j;
				if (v.size() > s.size())//如果此时变量长度大于字符长度了就匹配下一个变量
				{
					continue;
				}
				string prfv = s.substr(s.size() - v.size(), v.size());
				//cout <<v<<":" << prfv;
				if (v == prfv)
				{
					G.P[i].right.insert(G.P[i].right.begin(), v);
					//cout << G.P[i].right[0] << " ";
					s.erase(s.size() - v.size());
				}
				//cout << endl;

			}

			for (auto j = G.T.begin(); j != G.T.end(); j++)//再用终结符集合去匹配
			{
				string t = *j;
				if (t.size() > s.size())//如果此时终结符长度大于字符长度了就匹配下一个终结符
				{
					continue;
				}
				string prft = s.substr(s.size() - t.size(), t.size());
				//cout << t << ":" << prft;
				if (t == prft)
				{
					G.P[i].right.insert(G.P[i].right.begin(), t);
					//cout << G.P[i].right[0] << " ";
					s.erase(s.size() - t.size());
				}
				//cout << endl;

			}
			if (s.size() < x)
			{
				flag++;
			}
		}
		if (s.size() > 0)
		{
			cout << "产生式中出现了不是变量也不是终结符的变量";
			exit(0);
		}
	}
}

int showG(grammar& G)
{
	cout << "\n\n终结符：";
	cout << endl << "\t";
	for (auto i = G.T.begin(); i != G.T.end(); i++)
	{
		cout << *i << " ";
	}
	cout << "\n\n变量：";
	cout << endl << "\t";
	for (auto i = G.V.begin(); i != G.V.end(); i++)
	{
		cout << *i << " ";
	}
	cout << "\n\n产生式：";
	cout << endl;
	for (int i = 0; i < G.P.size(); i++)
	{
		cout << "\t" << G.P[i].left << "->";
		for (int j = 0; j < G.P[i].right.size(); j++)
		{
			cout << G.P[i].right[j];
		}
		cout << endl;
	}
	cout << "\n\nFIRSTOP集：";
	cout << endl;
	for (auto i = G.FIRSTOP.begin(); i != G.FIRSTOP.end(); i++)
	{
		cout << "\tFIRSTOP(" << i->first << "):\t{ ";
		auto s = i->second.begin();
		s++;
		for (auto j = i->second.begin(); j != i->second.end(); j++)
		{
			cout << *j;
			if (s != i->second.end())
			{
				cout << ",";
				s++;
			}
		}
		cout << " }\n";
	}
	cout << "\n\nLASTOP集：";
	cout << endl;
	for (auto i = G.LASTOP.begin(); i != G.LASTOP.end(); i++)
	{
		cout << "\tLASTOP(" << i->first << "):\t{ ";
		auto s = i->second.begin();
		s++;
		for (auto j = i->second.begin(); j != i->second.end(); j++)
		{
			cout << *j;
			if (s != i->second.end())
			{
				cout << ",";
				s++;
			}
		}
		cout << " }\n";
	}
	return 0;
}

void getFIRSTOP(grammar &G)
{
	int flag = 0;
	while (flag!=1)
	{
		flag = 1;
		for (int i = 0; i < G.P.size(); i++)
		{
			int x = G.FIRSTOP[G.P[i].left].size();
			if (G.T.find(G.P[i].right[0]) != G.T.end())//这里是处理如果产生式第一个是终结符则把这个终结符加入到这个产生式左部的firstop集合里去
			{
				G.FIRSTOP[G.P[i].left].insert(G.P[i].right[0]);
			}
			else //把这个产生式右部第一个变量之后的终结符加入到这个产生式左部的firstop集合里去，还要把第一个变量的firstop集合加入到这个产生式左部的firstop集合里去
			{
				for (auto j = G.FIRSTOP[G.P[i].right[0]].begin(); j != G.FIRSTOP[G.P[i].right[0]].end(); j++)
				{
					G.FIRSTOP[G.P[i].left].insert(*j);
				}
				if (G.P[i].right.size() >= 2)
				{
					G.FIRSTOP[G.P[i].left].insert(G.P[i].right[1]);
				}
			}
			if (G.FIRSTOP[G.P[i].left].size() > x)
			{
				flag++;
			}
		}
	}
}

void getLASTOP(grammar &G)//类似与求firstop的方法
{
	int flag = 0;
	while (flag != 1)
	{
		flag = 1;
		for (int i = 0; i < G.P.size(); i++)
		{
			int x = G.LASTOP[G.P[i].left].size();
			int m = G.P[i].right.size();
			if (G.T.find(G.P[i].right[m-1]) != G.T.end())//这里是处理如果产生式倒数第一个是终结符则把这个终结符加入到这个产生式左部的lastop集合里去
			{
				G.LASTOP[G.P[i].left].insert(G.P[i].right[m-1]);
			}
			else //把这个产生式右部倒数第一个变量之后的终结符加入到这个产生式左部的lastop集合里去，还要把第一个变量的lastop集合加入到这个产生式左部的lastop集合里去
			{
				for (auto j = G.LASTOP[G.P[i].right[m-1]].begin(); j != G.LASTOP[G.P[i].right[m-1]].end(); j++)
				{
					G.LASTOP[G.P[i].left].insert(*j);
				}
				if (G.P[i].right.size() >= 2)
				{
					G.LASTOP[G.P[i].left].insert(G.P[i].right[m-2]);
				}
			}
			if (G.LASTOP[G.P[i].left].size() > x)
			{
				flag++;
			}
		}
	}
}

void getPriority_Relationship_Matrix(grammar &G)
{
	for (auto i = G.T.begin(); i != G.T.end(); i++)//先创建这个表
	{
		Priority_Relationship_Matrix[*i];
		for (auto j = G.T.begin(); j != G.T.end(); j++)
		{
			Priority_Relationship_Matrix[*i][*j];
		}
	}
	for (int i = 0; i < G.P.size(); i++)//直接遍历这个产生式如果有终结符就处理
	{
		for (int j = 0; j < G.P[i].right.size(); j++)//经过分析大部分都符合这个情况，之后处理可能出现的情况（开头和末尾是终结符，按照这个文法来说不可能出现这种情况）
		{
			if (G.T.find(G.P[i].right[j]) != G.T.end())//如果此时的这个是终结符
			{
				if (j + 1 < G.P[i].right.size()&&G.T.find(G.P[i].right[j + 1]) != G.T.end())//如果后面的一个是终结符
				{
					Priority_Relationship_Matrix[G.P[i].right[j]][G.P[i].right[j + 1]] = "=";
				}
				else
				{
					if (j + 1 < G.P[i].right.size())
					{
						for (auto f = G.FIRSTOP[G.P[i].right[j + 1]].begin(); f != G.FIRSTOP[G.P[i].right[j + 1]].end(); f++)//处理后面是变量的情况
						{
							Priority_Relationship_Matrix[G.P[i].right[j]][*f] = "<";
						}
					}
					if (j + 2 < G.P[i].right.size() && G.T.find(G.P[i].right[j + 2]) != G.T.end())//如果变量之后是终结符
					{
						Priority_Relationship_Matrix[G.P[i].right[j]][G.P[i].right[j + 2]] = "=";
					}
				}
				
				if (j - 1 >= 0 && G.T.find(G.P[i].right[j - 1]) == G.T.end())//如果前面的一个是变量
				{
					for (auto l = G.LASTOP[G.P[i].right[j - 1]].begin(); l != G.LASTOP[G.P[i].right[j - 1]].end(); l++)//处理前面是变量的情况
					{
						Priority_Relationship_Matrix[*l][G.P[i].right[j]] = ">";
					}
				}
			}
		}
		Priority_Relationship_Matrix["#"]["#"] = "停止";
		/*
		if (G.T.find(G.P[i].right[0]) != G.T.end()&& G.P[i].right.size()>=2)//如果第一个是终结符
		{
			for (auto f = G.FIRSTOP[G.P[i].right[1]].begin(); f != G.FIRSTOP[G.P[i].right[1]].end(); f++)//处理后面是变量的情况
			{
				Priority_Relationship_Matrix[G.P[i].right[0]][*f] = "<";
			}
		}
		if (G.T.find(G.P[i].right[G.P[i].right.size() - 1]) != G.T.end()&& G.P[i].right.size() >= 2)//如果最后一个是终结符
		{
			for (auto l = G.LASTOP[G.P[i].right[G.P[i].right.size() - 2]].begin(); l != G.LASTOP[G.P[i].right[G.P[i].right.size() - 2]].end(); l++)//处理前面是变量的情况
			{
				Priority_Relationship_Matrix[*l][G.P[i].right[G.P[i].right.size() - 1]] = ">";
			}
		}
		*/
	}
}

void showPriority_Relationship_Matrix()
{
	cout << "\n优先关系矩阵为：" << endl;
	for (auto j = (Priority_Relationship_Matrix.begin())->second.begin();j!= (Priority_Relationship_Matrix.begin())->second.end();j++)
	{
		cout << "\t" << j->first;
	}
	cout << endl;
	for (auto i = Priority_Relationship_Matrix.begin(); i != Priority_Relationship_Matrix.end(); i++)
	{
		cout << i->first<<"\t";
		for (auto j = i->second.begin(); j != i->second.end(); j++)
		{
			cout << Priority_Relationship_Matrix[i->first][j->first]<<"\t";
		}
		cout << endl;
	}
}

void split_sentence(string s, grammar G, vector<string>& sentence)
{
	int flag = 0;
	while (flag != 1)
	{
		flag = 1;
		int x = s.size();
		for (auto j = G.V.begin(); j != G.V.end(); j++)//先用变量集合去匹配
		{
			string v = *j;
			if (v.size() > s.size())//如果此时变量长度大于字符长度了就匹配下一个变量
			{
				continue;
			}
			string prfv = s.substr(s.size() - v.size(), v.size());
			if (v == prfv)
			{
				sentence.insert(sentence.begin(), v);
				s.erase(s.size() - v.size());
			}

		}
		for (auto j = G.T.begin(); j != G.T.end(); j++)//再用终结符集合去匹配
		{
			string t = *j;
			if (t.size() > s.size())//如果此时终结符长度大于字符长度了就匹配下一个终结符
			{
				continue;
			}
			string prft = s.substr(s.size() - t.size(), t.size());
			if (t == prft)
			{
				sentence.insert(sentence.begin(), t);
				s.erase(s.size() - t.size());
			}
		}
		if (s.size() < x)
		{
			flag++;
		}
	}
	sentence.push_back("#");
	if (s.size() > 0)
	{
		cout << "产生式中出现了不是变量也不是终结符的变量";
		exit(0);
	}
	/*
	for (int i = 0; i < sentence.size(); i++)
	{
		cout << sentence[i]<<"$";
	}
	*/
}

void showanalysis(int i,vector<string>&s,string &Priority_relationship,string &id,vector<string> &input)
{
	cout << i << " \t";
	cout <<"" << setw(8);
	for (int i = 0; i < s.size(); i++)
	{
		cout << s[i];
	}
	cout <<"\t"<<setw(8)<< Priority_relationship << "\t\t" << id << "\t\t";
	for (int i = 0; i < input.size(); i++)
	{
		cout << input[i];
	}
	cout << "\n";
}

void analysis(vector<string>&setence,grammar&G)
{
	cout <<"步骤\t       栈\t       优先关系\t        当前输入字符R\t输入字符串" << endl;

	vector<string>an;
	an.push_back("#");
	int number = 0;
	string R = setence[0];
	setence.erase(setence.begin() + 0);
	while (1)
	{
		int i = an.size() - 1;
		while (i > 0)
		{
			if (G.T.find(an[i]) != G.T.end())
			{
				break;
			}
			i--;
		}
		if (R == "#" && an[i] == "#")
		{
			break;
		}
		showanalysis(number, an, Priority_Relationship_Matrix[an[i]][R], R, setence);
		while(Priority_Relationship_Matrix[an[i]][R] == ">")
		{
			string Q=an[i];
			int j = i - 1;
			while(j >= 0 && G.T.find(an[j])==G.T.end()) 
			{
				j--;
				
			}
			while (j>=0 && Priority_Relationship_Matrix[an[j]][Q] != "<")
			{
				if (Priority_Relationship_Matrix[an[j]][Q] == "=")
				{
					Q = an[j];
					j--;
				}
				while (j>=0 && G.T.find(an[j]) == G.T.end() )
				{
					j--;
				}
			}
			while (an.size() - 1 > j)
			{
				an.pop_back();
			}
			i = j;
			an.push_back("N");
			number++;
			showanalysis(number, an, Priority_Relationship_Matrix[an[i]][R], R, setence);
		}
		if(Priority_Relationship_Matrix[an[i]][R] == "<" || Priority_Relationship_Matrix[an[i]][R] == "=" || Priority_Relationship_Matrix[an[i]][R]=="停止")
		{
			an.push_back(R);
		}
		else
		{
			cout << "出错，分析的句子不符合此文法！！！";
			exit(0);
		}
		number++;
		if (setence.size() > 0)
		{
			R = setence[0];
			setence.erase(setence.begin() + 0);
		}
		
	}
}

int main()
{
	ifstream infile;
	infile.open("production.txt");
	grammar G;
	string s;
	infile >> s;
	//cin >> s;
	cout << "请先输入终结符(输入stop表示终结符输入完成)：\n";
	while (s != "stop")
	{
		G.T.insert(s);
		infile >> s;
		//cin >> s;
	}
	cout << "\n请输入产生式(输入stop表示产生式输入完毕):\n";
	infile >> s;
	//cin >> s;
	while (s != "stop")
	{
		split(G.P, s);
		infile >> s;
		//cin >> s;
	}
	getV_PR_S(G);
	getFIRSTOP(G);
	getLASTOP(G);
	showG(G);
	getPriority_Relationship_Matrix(G);
	showPriority_Relationship_Matrix();
	vector<string>setence;
	cout << "\n请输入要分析的式子：\n";
	infile >> s;
	split_sentence(s, G, setence);
	analysis(setence, G);
	infile.close();
	return 0;
}

？@？567
关注
自下而上的分析法——算符优先分析法
记录时间带走的东西
05-13 4万+
概述 算符优先分析法(Operator Precedence Parse)是仿效四则运算的计算过程而构造的一种语法分析方法。算符优先分析法的关键是比较两个相继出现的终结符的优先级而决定应采取的动作。 优点：简单，有效，适合表达式的分析。 缺点：只适合于算符优先文法，是一个不大的文法类。 名词解释 定义： 短语：设有文法G，S是开始符号，...
【编译原理】算符优先分析法
记录我的学习历程
05-27 888
output = f"({count})\t {AnalyseStack}\t {p}\t {a}\t {' ' * 17}{rem}\t 移进"其基本思想是：首先规定算符，这里是文法的终结符之间的优先关系，然后根据这种优先关系，通过比较相邻算符的优先次序来确定句型中的“句柄”，然后进行归约。为了降低实现的难度，本实验只要求实现步骤（3）的部分，即手动实现步骤（1）和（2），然后依据步骤（2）建立的分析表编写一个总控程序，实现句子的分析。print("错误！
java编程实现算符优先分析法,编译原理实验三-算符优先分析法
weixin_39816448的博客
03-16 910
编译原理实验3-算符优先分析法#include#include#include#include#define SIZE 128char priority[6][6]; //算符优先关系表数组char input[SIZE]; //存放输入的要进行分析的句子char remain[SIZE]; //存放剩余串char AnalyseStack[SIZE]; //分析栈void an...
算符优先分析法-java实现
tiandc的博客
12-29 6483
算符优先分析器-java实现 一、判断是否是算符文法 算符文法定义:一个文法，如果它的任一产生式的右部都不含两个相继(并列)的非终结符，即不含如下形式的产生式右部:…QR…,则称该文法为算符文法 二、求Firstvt和Lastvt(…为终结符和非终结符组成的任意序列，包括空字) Firstvt (1)若有产生式P->a…或Ｐ->Qa…,则a ∈FIRSTVT§; (2)若a∈FIR...
编译原理实验二——算符优先分析法设计与实现
08-29
算符优先分析法是一种常用的语法分析方法，用于解决编译器的语法分析阶段问题。本实验旨在通过实际操作加深学生对算符优先分析法的理解，并提高程序设计能力。 【实验内容与步骤】 1. **定义目标语言的语法规则**...
编译原理-实验3算符优先分析法[定义].pdf
10-12
编译原理-实验3算符优先分析法[定义] 编译原理-实验3算符优先分析法[定义]是编译原理中的一种重要实验，旨在加深对语法分析器工作过程的理解，掌握算符优先分析法实现语法分析程序，并采用一种编程语言实现简单的...
算符优先分析法.doc.rar_E->E+T_E->E+T E->E—T_GME_doc_编译原理
07-15
编译原理实验 对下述描述算符表达式的算符优先文法G[E],给出算符优先分析的实验结果。 实验内容： 有上下无关文法如下： E->E+T|E-T|T T->T*F|T/F|F F->(E)|i
实验三 算符优先分析算法的设计与实现.doc
03-11
本实验的目的是通过算符优先分析法对表达式进行语法分析，使其能够判断一个表达式是否正确。通过算符优先分析方法的实现，加深对自下而上语法分析方法的理解。 二、 实验要求 1. 输入文法：可以是如下算术表达式的...
编译原理课程设计---java实现算符优先分析法
04-26
在编译原理中，算符优先分析法是一种用于解析程序语法结构的方法，它基于算符的优先级和结合性来构建语法分析表。本课程设计是关于如何使用Java语言实现这个算法，这对于理解和掌握编译器构造有重要的实践意义。 ...
java实现算符优先分析法
06-04
算符优先分析法是一种常用的解析技术，尤其适用于处理表达式。本文将深入探讨算符优先分析法的概念、工作原理，以及如何使用Java来实现这一算法。 算符优先分析法基于算符的优先级和结合性，用于解析表达式。它的...
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 87
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
STL set
最新发布
hls0611的博客
11-09 143
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C 学习（4）
search7的博客
11-05 772
C语言学习，每个模块来自工作中的？？？
常用的c++特性--＞day02
m0_69093426的博客
11-06 548
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 209
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 614
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
【C++】详解RAII思想与智能指针
谁在夜里看海.的博客
11-09 1482
上一篇关于异常处理的文章，我们提到，异常处理是存在内存泄漏风险的，由于异常捕获会导致程序运行时执行流的跳转，并且在某些资源释放之前就进行了跳转，此时就会引发内存泄漏。什么是内存泄漏呢？内存泄漏是指程序在运行的过程中，动态分配的内存被占用但没有得到释放，从而导致资源不能被回收，最终可能导致系统性能下降甚至崩溃。
c++之 stack(栈)和queue(队列)
2301_80028974的博客
11-04 849
文档stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值