中缀表达式

最新推荐文章于 2025-04-01 17:20:02 发布

ai309581115

最新推荐文章于 2025-04-01 17:20:02 发布

阅读量1.8k

点赞数

分类专栏：算法

算法专栏收录该内容

3 篇文章

订阅专栏

学习算法，开始想到用栈了，但是没有解决优先级的问题。上网一查，原来中缀表达式更适合计算机阅读，转换成中缀表达式后，只需把转换好的数据压栈，遇到运算符就取出两个操作数的顺序第一个取出的放到运算符右侧运算之后压栈直到结束，取出栈顶数据就是结果。

编写时自己实现的函数

int count = -1;
char pop(){
	return stack[count--];
}

char top(){
	return stack[count];
}

void push(char t){
	stack[++count]=t;
}

别人比较好的代码

字符串转换为数字

<span style="white-space:pre">		</span>x = 0;  
                while('0' <= s2[i]&&s2[i] <= '9')  
                {  
                    x = x*10+s2[i] - '0';  
                    i++;  
                }  
                if(s2[i] == '.')  
                {  
                    double k = 10.0;  
                    y = 0;  
                    i++;  
                    while('0' <= s2[i]&&s2[i] <= '9')  
                    {  
                        y += ((s2[i]-'0')/k);  
                        i++;  
                        k *= 10;  
                    }  
                    x += y;  
                }

原帖：http://www.nowamagic.net/librarys/veda/detail/2307

我们把平时所用的标准四则运算表达式，即“9+(3-1)*3+10/2"叫做中缀表达式。因为所有的运算符号都在两数字的中间，现在我们的问题就是中缀到后缀的转化。

中缀表达式“9+(3-1)*3+10/2”转化为后缀表达式“9 3 1-3*+ 10 2/+”

规则：从左到右遍历中缀表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于找顶符号（乘除优先加减）则栈顶元素依次出找并输出，并将当前符号进栈，一直到最终输出后缀表达式为止。

下面我们来具体看看这个过程。

1. 初始化一空栈，用来对符号进出栈使用。

2. 第一个字符是数字9，输出9，后面是符号“+”，进栈。

3. 第三个字符是“(”,依然是符号，因其只是左括号，还未配对，故进栈。

4. 第四个字符是数字3，输出，总表达式为9 3,接着是“-”进栈。

5. 接下来是数字1，输出，总表达式为9 3 1，后面是符号“)”，此时，我们需要去匹配此前的“(”，所以栈顶依次出栈，并输出，直到“(”出栈为止。此时左括号上方只有“-”，因此输出“-”，总的输出表达式为9 3 1 -

6. 接着是数字3，输出，总的表达式为9 3 1 - 3 。紧接着是符号“*”，因为此时的栈顶符号为“+”号，优先级低于“*”，因此不输出，进栈。

7. 之后是符号“+”，此时当前栈顶元素比这个“+”的优先级高，因此栈中元素出栈并输出（没有比“+”号更低的优先级，所以全部出栈），总输出表达式为 9 3 1 - 3 * +.然后将当前这个符号“+”进栈。也就是说，前6张图的栈底的“+”是指中缀表达式中开头的9后面那个“+”，而下图中的栈底（也是栈顶）的“+”是指“9+(3-1)*3+”中的最后一个“+”。

8. 紧接着数字10，输出，总表达式变为9 3 1-3 * + 10。

9. 最后一个数字2,输出，总的表达式为 9 3 1-3*+ 10 2

10. 因已经到最后，所以将栈中符号全部出栈并输出。最终输出的后缀表达式结果为 9 3 1-3*+ 10 2/+

从刚才的推导中你会发现，要想让计算机具有处理我们通常的标准（中缀）表达式的能力，最重要的就是两步：

将中缀表达式转化为后缀表达式（栈用来进出运算的符号）。
将后缀表达式进行运算得出结果（栈用来进出运算的数字）。

整个过程，都充分利用了找的后进先出特性来处理，理解好它其实也就理解好了栈这个数据结构。

/*
*    这里主要是逆波兰式的实现，使用两个stack 这里用字符串来模拟一个stack，第一步，将中缀表达式转变为后缀表达式
*    第二步，然后再使用一个stack，计算后缀表达式的结果，这一步很容易出错，考虑到浮点数的问题。
*/
#include <iostream>
#include <string>
#include <stack>
#include <iomanip>

using namespace std;

int cmp(char ch)     // 运算符优先级 
{
	switch(ch)
	{
		case '+':
		case '-': return 1;
		case '*':
		case '/': return 2;
		default : return 0;
	}
}
void change(string &s1, string &s2)       // 中缀表达式转变后缀表达式 
{
	stack <char > s;
	s.push('#');
	int i = 0;
	while(i < s1.length()-1)
	{
		if(s1[i] == '(')
		{
			s.push(s1[i++]);
		}
		else if(s1[i] == ')')
		{
			while(s.top() != '(')
			{
				s2 += s.top();
				s2 += ' ';
				s.pop();
			}
			s.pop();
			i++;
		}
		else if(s1[i] == '+'||s1[i] == '-'||s1[i] == '*'||s1[i] == '/')
		{
			while(cmp(s.top()) >= cmp(s1[i]))
			{
				s2 += s.top();
				s2 += ' ';
				s.pop();
			}
			s.push(s1[i]);
			i++;
		}
		else
		{
			while('0' <= s1[i]&&s1[i] <= '9'||s1[i] == '.')
			{
				s2 += s1[i++];
			}
			s2 += ' ';
		}
	}
	while(s.top() != '#')
	{
		s2 += s.top();
		s2 += ' ';
		s.pop();
	}
}

double value(string s2)         // 计算后缀表达式，得到其结果。 
{
	stack < double> s;
	double x,y;
	int i = 0;
	while(i < s2.length())
	{
		if(s2[i] == ' ')
		{
			i++;
			continue;
		}
		switch(s2[i])
		{
			case '+': x = s.top(); s.pop(); x += s.top(); s.pop(); i++; break;
			case '-': x = s.top(); s.pop(); x =s.top()-x; s.pop(); i++; break;
			case '*': x = s.top(); s.pop(); x *= s.top(); s.pop(); i++; break;
			case '/': x = s.top(); s.pop(); x = s.top()/x; s.pop(); i++; break;
			default :
			{
				x = 0;
				while('0' <= s2[i]&&s2[i] <= '9')
				{
					x = x*10+s2[i] - '0';
					i++;
				}
				if(s2[i] == '.')
				{
					double k = 10.0;
					y = 0;
					i++;
					while('0' <= s2[i]&&s2[i] <= '9')
					{
						y += ((s2[i]-'0')/k);
						i++;
						k *= 10;
					}
					x += y;
				}
			}
		}
		s.push(x);
	}
	return s.top();
}
int main(int argc, char const *argv[])
{
	int n;
	string s1,s2;
	cin>>n;
	while(n--)
	{
		cin>>s1;
		s2 = "";
		change(s1,s2);
		cout<<fixed<<setprecision(2)<<value(s2)<<endl;
	}
	return 0;
}