【栈】736. Lisp 语法解析

本文涉及知识点

栈

LeetCode736. Lisp 语法解析

给你一个类似 Lisp 语句的字符串表达式 expression，求出其计算结果。

表达式语法如下所示:

表达式可以为整数，let 表达式，add 表达式，mult 表达式，或赋值的变量。表达式的结果总是一个整数。

(整数可以是正整数、负整数、0)

let 表达式采用 "(let v1 e1 v2 e2 ... vn en expr)" 的形式，其中 let 总是以字符串 "let"来表示，接下来会跟随一对或多对交替的变量和表达式，也就是说，第一个变量 v1被分配为表达式 e1 的值，第二个变量 v2 被分配为表达式 e2 的值，依次类推；最终 let 表达式的值为 expr表达式的值。

add 表达式表示为 "(add e1 e2)" ，其中 add 总是以字符串 "add" 来表示，该表达式总是包含两个表达式 e1、e2 ，最终结果是 e1 表达式的值与 e2 表达式的值之 和 。

mult 表达式表示为 "(mult e1 e2)" ，其中 mult 总是以字符串 "mult" 表示，该表达式总是包含两个表达式 e1、e2，最终结果是 e1 表达式的值与 e2 表达式的值之 积 。

在该题目中，变量名以小写字符开始，之后跟随 0 个或多个小写字符或数字。为了方便，"add" ，"let" ，"mult" 会被定义为 "关键字" ，不会用作变量名。

最后，要说一下作用域的概念。计算变量名所对应的表达式时，在计算上下文中，首先检查最内层作用域（按括号计），然后按顺序依次检查外部作用域。测试用例中每一个表达式都是合法的。有关作用域的更多详细信息，请参阅示例。

示例 1：

输入：expression = "(let x 2 (mult x (let x 3 y 4 (add x y))))"

输出：14

解释：

计算表达式 (add x y), 在检查变量 x 值时，

在变量的上下文中由最内层作用域依次向外检查。

首先找到 x = 3, 所以此处的 x 值是 3 。

示例 2：

输入：expression = "(let x 3 x 2 x)"

输出：2

解释：let 语句中的赋值运算按顺序处理即可。

示例 3：

输入：expression = "(let x 1 y 2 x (add x y) (add x y))"

输出：5

解释：

第一个 (add x y) 计算结果是 3，并且将此值赋给了 x 。

第二个 (add x y) 计算结果是 3 + 2 = 5 。

提示：

1 <= expression.length <= 2000

exprssion 中不含前导和尾随空格

expressoin 中的不同部分（token）之间用单个空格进行分隔

答案和所有中间计算结果都符合 32-bit 整数范围

测试用例中的表达式均为合法的且最终结果为整数

栈

包括 标识符（变量关键字） 常量 （ ）

递归解析每个括号。unorder_map<string,stack> m_mVar 记录各变量的值。

一个括号从左到右解析，解析到变量入栈，本括号解析结束出栈。注意 ：不能先解析最内层括号，比如：(let x 2 add(x 1)) 先解析add会检测到未定义变量，而误认为是非法字符串。

Parse 函数大致流程：

一，如果有前置空格，忽略。忽略左括号。

二，解析命令名。

三，如果是加或乘法，读取两个值。并返回结果。

四，读取变量，如果失败则读值。

五，忽略空格后，如果是右括号。则计算返回值，并变量出栈。

六，忽略空格后，如果不是右括号。读取值，更新变量的值，并入栈。

IgronSpace ：如果有空格，则忽略。

GetNum1：读取值，包括变量 常量 表达式。

ParseName：解析变量名，字母开始，后效字符可以是字母，也可以是数字。

ParseNum：解析数字和表达式。
注意：iPos指向下一个待处理的字符。

代码

核心代码

class Solution {
public:
	int evaluate(string expression) {
		m_exp = expression;
		int iPos = 0;
		return Parse(iPos);
	}
	int Parse(int& iPos) {
		auto tmp = m_exp.substr(iPos);
		while ((iPos < m_exp.length()) && ('(' != m_exp[iPos])) {
			iPos++;
		}
		iPos += 1;//跳过(和空格
		string strName = ParseName(iPos);
		iPos++;
		if ("mult" == strName) {
			int num1 = GetNum1(iPos);
			int num2 = GetNum1(++iPos);
			IgronSpace(iPos);
			iPos++;
			return num1 * num2;
		}
		if ("add" == strName) {
			int num1 = GetNum1(iPos);
			int num2 = GetNum1(++iPos);
			IgronSpace(iPos);
			iPos++;
			return num1 + num2;
		}
		assert("let" == strName);
		vector<string> vars;
		while (true) {
			auto iRet = 0;
			string strVarName = ParseName(iPos);
			if ("" != strVarName) {
				IgronSpace(iPos);					
			}
			else {
				iRet += GetNum1(iPos);
				IgronSpace(iPos);
			}
			if (')' == m_exp[iPos]) { 
				if ("" != strVarName)
				{
					iRet = m_mVar[strVarName].top();
				}
				for (auto var : vars) {//变量出栈
					m_mVar[var].pop();
				}
				iPos++;
				return  iRet;
			}
			vars.emplace_back(strVarName);
			const int cur = GetNum1(iPos);
			m_mVar[strVarName].emplace();
			m_mVar[strVarName].top() = cur;
			iPos++;
		}
	}
	void IgronSpace(int& iPos) {
		if((iPos < m_exp.length())&&(' ' == m_exp[iPos])){iPos++;};
	}
	int GetNum1(int& iPos) {
		string strName = ParseName(iPos);
		if ("" != strName) { return m_mVar[strName].top(); }
		return ParseNum(iPos);
	}
	string ParseName(int& iPos) {
		string strName;
		while ((isalpha(m_exp[iPos]))||(strName.size() && isalnum(m_exp[iPos]))) {
			strName += m_exp[iPos++];
		}
		return strName;
	}
	int ParseNum(int& iPos) {
		int num = 0;
		if ('(' == m_exp[iPos]) { return Parse(iPos); }
		int iSign = 1;
		if ('-' == m_exp[iPos]) {
			iSign = -1; iPos++;
		}
		while (isdigit(m_exp[iPos])) {
			num = num*10+ (m_exp[iPos]-'0');
			iPos++;
		}
		return iSign* num;
	}
	unordered_map<string, stack<int>> m_mVar;
	string m_exp;
};

单元测试

template<class T1,class T2>
void AssertEx(const T1& t1, const T2& t2)
{
	Assert::AreEqual(t1 , t2);
}

template<class T>
void AssertEx(const vector<T>& v1, const vector<T>& v2)
{
	Assert::AreEqual(v1.size(), v2.size());	
	for (int i = 0; i < v1.size(); i++)
	{
		Assert::AreEqual(v1[i], v2[i]);
	}
}

template<class T>
void AssertV2(vector<vector<T>> vv1, vector<vector<T>> vv2)
{
	sort(vv1.begin(), vv1.end());
	sort(vv2.begin(), vv2.end());
	Assert::AreEqual(vv1.size(), vv2.size());
	for (int i = 0; i < vv1.size(); i++)
	{
		AssertEx(vv1[i], vv2[i]);
	}
}

namespace UnitTest
{
	string expression;
	TEST_CLASS(UnitTest)
	{
	public:
		TEST_METHOD(TestMethod0)
		{
			expression = "(let x 2 (mult x (let x 3 y 4 (add x y))))";
			auto res = Solution().evaluate(expression);
			AssertEx(14,res);
		}
		TEST_METHOD(TestMethod1)
		{
			expression = "(let x 3 x 2 x)";
			auto res = Solution().evaluate(expression);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod2)
		{
			expression = "(let x 1 y 2 x (add x y) (add x y))";
			auto res = Solution().evaluate(expression);
			AssertEx(5, res);
		}
		TEST_METHOD(TestMethod3)
		{
			expression = "(let x 7 -12)";
			auto res = Solution().evaluate(expression);
			AssertEx(-12, res);
		}
		TEST_METHOD(TestMethod5)
		{
			expression = "(let x 2 (add (let x 3 (let x 4 x)) x))";
			auto res = Solution().evaluate(expression);
			AssertEx(6, res);
		}
		TEST_METHOD(TestMethod6)
		{
			expression = "(let x 2 (add (let x 3 4) x))";
			auto res = Solution().evaluate(expression);
			AssertEx(6, res);
		}
		TEST_METHOD(TestMethod7)
		{
			expression = "(let x 2 (add 4 x))";
			auto res = Solution().evaluate(expression);
			AssertEx(6, res);
		}
		TEST_METHOD(TestMethod8)
		{
			expression = "(let a1 3 b2 (add a1 1) b2)";
			auto res = Solution().evaluate(expression);
			AssertEx(4, res);
		}
	};
}

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
《喜缺全书算法册》以原理、正确性证明、总结为主。
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17

或者 操作系统：win10 开发环境： VS2022 C++17

如无特殊说明，本算法用**C++**实现。