一： 中缀表达式求值
思想：
需要2个栈，运算对象栈OPND,运算符栈OPTR，
1:将栈OPND初始化为空，栈OPTR初始化为表达式的定界符#
2:扫描表达式，直到遇到结束符#
2.1:当前字符是运算对象，入栈OPND
2.2:当前字符是运算符且优先级比栈OPTR的栈顶运算符优先级高，入栈OPTR,处理下一个字符
2.3:当前字符是运算符且优先级比栈OPTR的栈顶运算符优先级低，则从栈OPND出栈2个运算对象，从栈OPTR出栈一个运算符进行运算，并将运算结果入栈OPND,处理当前字符
2.4:当期字符是运算符且优先级与栈OPTR的栈顶运算符的优先级相同，将栈OPTR的栈顶运算符出栈，出理下一个字符。
3：输出栈OPND中的栈顶元素，即运算结果
//expseqstack.h
//10只是示例性的数据，可以根据实际问题具体定义
const int StackSize=10;
typedef struct
{
char op;
int inputprecedence;
int stackprecedence;
}DataType1;
template <class T> //定义模板类SeqStack
class SeqStack
{
public:
SeqStack(); //构造函数，栈的初始化
~SeqStack(); //析构函数
void init();
void Push(T x); //将元素x入栈
T Pop(); //将栈顶元素弹出
T GetTop(); //取栈顶元素（并不删除）
bool Empty(); //判断栈是否为空
public:
T data[StackSize]; //存放栈元素的数组
int top; //栈顶指针，指示栈顶元素在数组中的下标
};
/*
* 前置条件：栈不存在
* 输 入：无
* 功 能：栈的初始化
* 输 出：无
* 后置条件：构造一个空栈
*/
template <class T>
SeqStack<T>::SeqStack()
{
top=-1;
}
/*
* 前置条件：栈已存在
* 输 入：无
* 功 能：销毁栈
* 输 出：无
* 后置条件：释放栈所占用的存储空间
*/
template <class T>
SeqStack<T>::~SeqStack()
{
}
template <class T>
void SeqStack<T>::init()
{
top=0;
}
/*
* 前置条件：栈已存在
* 输 入：元素值x
* 功 能：在栈顶插入一个元素x
* 输 出：如果插入不成功，抛出异常
* 后置条件：如果插入成功，栈顶增加了一个元素
*/
template <class T>
void SeqStack<T>::Push(T x)
{
if (top== StackSize-1) throw "上溢";
top++;
data[top]=x;
}
/*
* 前置条件：栈已存在
* 输 入：无
* 功 能：删除栈顶元素
* 输 出：如果删除成功，返回被删元素值，否则，抛出异常
* 后置条件：如果删除成功，栈顶减少了一个元素
*/
template <class T>
T SeqStack<T>::Pop()
{
T x;
if (top==-1) throw "下溢";
x=data[top--];
return x;
}
/*
* 前置条件：栈已存在
* 输 入：无
* 功 能：读取当前的栈顶元素
* 输 出：若栈不空，返回当前的栈顶元素值
* 后置条件：栈不变
*/
template <class T>
T SeqStack<T>::GetTop()
{
if (top!=-1)
return data[top];
}
/*
* 前置条件：栈已存在
* 输 入：无
* 功 能：判断栈是否为空
* 输 出：如果栈为空，返回1，否则，返回0
* 后置条件：栈不变
*/
template <class T>
bool SeqStack<T>::Empty()
{
if(top==-1) return 1;
else return 0;
}
//main.cpp
#include"expseqstack.h"
#include<iostream>
#include<string>
using namespace std;
//检查符号之间的优先级，1表示>,0表示=，-1表示<，c1栈内的运算，c2栈外的运算
int check(char c1, char c2)
{
int a1, a2;
if (c1 == ‘+‘ || c1 == ‘-‘)
a1 = 3;
if (c1 == ‘*‘ || c1 == ‘/‘)
a1 = 5;
if (c1 == ‘(‘)
a1 = 1;
if (c1 == ‘)‘)
a1 = 7;
if (c1 == ‘#‘)
a1 = 0;
if (c2 == ‘+‘ || c2 == ‘-‘)
a2 = 2;
if (c2 == ‘*‘ || c2 == ‘/‘)
a2 = 4;
if (c2 == ‘(‘)
a2 = 6;
if (c2 == ‘)‘)
a2 = 1;
if (c2 == ‘#‘)
a2 = 0;
if (a1 > a2)
return 1;
if (a1 == a2)
return 0;
if (a1 < a2)
return -1;
}
//符号运算函数
double sum(char c, double d1, double d2)
{
switch (c)
{
case ‘+‘:
return d1 + d2;
break;
case ‘-‘:
return d1 - d2;
break;
case ‘*‘:
return d1 * d2;
break;
case ‘/‘:
return d1 / d2;
break;
default:
break;
}
}
int main()
{
char *op = "+-*/()#";
string str;
cout<<"请输入表达式："<<endl;
cin>>str;
//给表达式字符串str添加‘#’结束标志符
str.append(1, ‘#‘);
SeqStack<char> OPTR;//运算符栈
SeqStack<double> OPND;//操作数栈
int a = -1;
//先将‘#‘入栈
OPTR.Push(‘#‘);
while (true)
{
int b = a + 1;
a = str.find_first_of(op, a + 1);
if (a == string::npos)
break;
if (a != b)
{
string ss(str, b, a - b);
double d = atof(ss.c_str());
//数据先入栈
OPND.Push(d);
}
//运算符优先级比较
char val;
val=OPTR.GetTop();
int che = check(val, str[a]);
if (-1 == che)//栈外优先级大直接入栈
{
OPTR.Push(str[a]);
}
if (0 == che)//栈内外优先级相等则出栈
{
OPTR.Pop();
}
if (1 == che)//栈内优先级大，出栈进行运算
{
char val; double d1; double d2;
val=OPTR.GetTop();
d1=OPND.GetTop();
d1=OPND.Pop();
d2=OPND.GetTop();
d2=OPND.Pop();
d1 = sum(val, d2, d1);
//运算结果入栈
OPND.Push(d1);
OPTR.Pop();
a--;
}
}
double s;
s=OPND.GetTop();
cout <<s<<endl;
return 0;
}
二：中缀表达式转后缀表达式并求值
中缀表达式转后缀表达式思想：
1：栈S初始化为空栈
2：扫描表达式的每个字符，
2.1：当前字符是运算对象，输出此字符，处理下一个字符
2.2：当前字符是运算符且优先级比栈S的栈顶的运算符优先级高，此字符入栈S,处理下一个字符
2.3：当前字符是运算符且优先级比栈S的栈顶的运算符优先级低，则将栈S的栈顶元素弹出并输出
2.4：当前字符是运算符且优先级比栈S的栈顶的运算符优先级相同，则将栈S的栈顶元素弹出，处理下一个字符
注：只有遇到 ) 的情况下，才弹出 ( ,但不输出。
例子：中缀表达式 3*(4+2)/2-5 ====>>后缀表达式3 4 2 + * 2 / 5 -
3 后缀表达式求值：
1:初始化栈S
2:扫描当前表达式
2.1当前字符是运算对象，则入栈S,处理下一个字符
2.2当前字符是运算符，则从栈S出栈2个运算对象，执行运算并将结果入栈S,处理下一个字符
3:输出栈S的栈顶元素，就是表达式结果。
//头文件 PrefixToPostfix.h #include <vector> using namespace std; bool isoperator(char op); // 判断是否为运算符 int priority(char op); // 求运算符优先级 void postfix(char pre[] , char post[],int &n); // 把中缀表达式转换为后缀表达式 double read_number(char str[],int *i); // 将数字字符串转变成相应的数字 double postfix_value(char post[]); // 由后缀表达式字符串计算相应的中值表达式的值
//PrefixToPostfix.cpp
#include "PrefixToPostfix.h"
#include"expseqstack.h"
#include <iostream>
using namespace std;
bool isoperator(char op)
{
switch(op)
{
case ‘+‘:
case ‘-‘:
case ‘*‘:
case ‘/‘:
return 1;
default :
return 0;
}
}
int priority(char op)
{
switch(op)
{
case ‘#‘:
return -1;
case ‘(‘:
return 0;
case ‘+‘:
case ‘-‘:
return 1;
case ‘*‘:
case ‘/‘:
return 2;
default :
return -1;
}
}
// 把中缀表达式转换为后缀表达式，返回后缀表达式的长度（包括空格）
void postfix(char pre[] ,char post[],int &n)
{
int i = 0 ,j=0;
SeqStack<char> stack;
stack.init(); // 初始化存储操作符的栈
stack.Push(‘#‘); // 首先把结束标志‘#’放入栈底
while(pre[i]!=‘#‘)
{
if((pre[i]>=‘0‘ && pre[i] <=‘9‘)||pre[i] ==‘.‘) // 遇到数字和小数点直接写入后缀表达式
{
post[j++] = pre[i];
n++;
}
else if (pre[i]==‘(‘) // 遇到“（”不用比较直接入栈
stack.Push(pre[i]);
else if(pre[i] ==‘)‘) // 遇到右括号将其对应左括号后的操作符（操作符栈中的）全部写入后缀表达式
{
while(stack.GetTop()!=‘(‘)
{
post[j++] = stack.Pop();
n++;
}
stack.Pop(); // 将“（”出栈，后缀表达式中不含小括号
}
else if (isoperator(pre[i]))
{
post[j++] = ‘ ‘; // 用空格分开操作数(
n++;
while(priority(pre[i]) <= priority(stack.GetTop()))
{
// 当前的操作符小于等于栈顶操作符的优先级时，将栈顶操作符写入到后缀表达式，重复此过程
post[j++] = stack.Pop();
n++;
}
stack.Push(pre[i]); // 当前操作符优先级大于栈顶操作符的优先级，将该操作符入栈
}
i++;
}
while(stack.top) // 将所有的操作符加入后缀表达式
{
post[j++] = stack.Pop();
n++;
}
}
double read_number(char str[],int *i)
{
double x=0.0;
int k = 0;
while(str[*i] >=‘0‘ && str[*i]<=‘9‘) // 处理整数部分
{
x = x*10+(str[*i]-‘0‘);
(*i)++;
}
if(str[*i]==‘.‘) // 处理小数部分
{
(*i)++;
while(str[*i] >= ‘0‘&&str[*i] <=‘9‘)
{
x = x * 10 + (str[*i]-‘0‘);
(*i)++;
k++;
}
}
while(k!=0)
{
x /= 10.0;
k--;
}
return x;
}
double postfix_value(char post[])
{
SeqStack<double> stack; // 操作数栈
stack.init();
int i=0 ;
double x1,x2;
while(post[i] !=‘#‘)
{
if(post[i] >=‘0‘ && post[i] <=‘9‘)
stack.Push(read_number(post,&i));
else if(post[i] == ‘ ‘)
i++;
else if (post[i] ==‘+‘)
{
x2 = stack.Pop();
x1 = stack.Pop();
stack.Push(x1+x2);
i++;
}
else if (post[i] ==‘-‘)
{
x2 = stack.Pop();
x1 = stack.Pop();
stack.Push(x1-x2);
i++;
}
else if (post[i] ==‘*‘)
{
x2 = stack.Pop();
x1 = stack.Pop();
stack.Push(x1*x2);
i++;
}
else if (post[i] ==‘/‘)
{
x2 = stack.Pop();
x1 = stack.Pop();
stack.Push(x1/x2);
i++;
}
}
return stack.GetTop();
}
//main.cpp
#include "PrefixToPostfix.h"
#include"expseqstack.h"
#include <iostream>
using namespace std;
void main()
{
SeqStack<int> stack ;
stack.init();
//char pre[] ="22/(5*2+1)#";
char exp[100];
cout << "输入表达式(中缀，以#结束)：";
cin >> exp;
char post[100] ;
//cout <<"中缀表达式为："<< pre << endl;
int n =0; // 返回后缀表达式的长度
postfix(exp,post,n);
cout <<"后缀表达式为：";
for( int i =0 ;i < n ;i++)
cout << post[i] ;
cout << "\n由后缀表达式计算出的数值结果: ";
cout << postfix_value(post) << endl;
system("pause");
}
时间： 2024-10-25 20:23:27