❶ 棧表示中綴表達式轉後綴表達式，棧中存放的是什麼內容
思路的話其實很簡單，就是構建一棵二叉樹，根節點和中間節點為運算符，葉子結點為運算數字。如 a + b*c， 構建為二叉樹的話，就如下圖： +a * b c對於該二叉樹，使用不同的遍歷方式就可以得到不同的表達式了。遍歷的代碼很簡單就不多說了。因此，你的問題主要可以分解為3個小問題：1。將後綴表達式轉換為二叉樹 該方法是最簡單的。如a + b*c 的後綴表達式為 bc*a+.處理步驟如下： 1。建立一個棧S 2。從左到右讀後綴表達式，讀到數字就創建葉子節點，節點值為數字值。將節點壓入棧S中，讀到運算符則創建中間節點，並從棧中依次彈出兩個節點分別為Y和X，作為中間節點的左右子節點，然後以「X 運算符 Y」的形式計算機出中間節點的值，再將此中間節點壓加棧S中 3。就重復第二步直至後綴表達式結束，此時棧頂的節點就是二叉樹的根節點了。2。將中綴表達式轉換為二叉樹 按照上一個回答者的方法將中綴表達式轉為後綴表達式，然後調用後綴表達式生成二叉樹的解法即可。3。將前綴表達式轉換為二叉樹 將前綴表達式直接取反即為後綴表達式。 如前綴表達式為+*bca，對應的後綴表達式為acb*+。因此，我們只需要字元串取反，然後調用後綴表達式的方法生成二叉樹即可。
❷ 用棧將一個將中綴表達式轉換為前綴表達式的演算法
1）求輸入串的逆序。
2）檢查輸入的下一元素。
3）假如是操作數，把它添加到輸出串中。
4）假如是閉括弧，將它壓棧。
5）假如是運算符，則
i)假如棧空，此運算符入棧。
ii)假如棧頂是閉括弧，此運算符入棧。
iii)假如它的優先順序高於或等於棧頂運算符，此運算符入棧。
iv)否則，棧頂運算符出棧並添加到輸出串中，重復步驟5。
6）假如是開括弧，棧中運算符逐個出棧並輸出，直到遇到閉括弧。閉括弧出棧並丟棄。
7）假如輸入還未完畢，跳轉到步驟2。
8）假如輸入完畢，棧中剩餘的所有操作符出棧並加到輸出串中。
9）求輸出串的逆序。*/
#include<iostream>
#include<string>
using namespace std;
char stack[50];//定義順序棧，其中第一個元素表示棧為空；
int top=0;//棧頂指針，為0表示棧為空；
int level(char op)//判斷運算符級別函數；其中* /的級別為2，+ -的級別為1；
{
int level;
switch(op)
{
case'+':
case'-':level=1; break;
case'*':
case'/':level=2; break;
default:level=0;break;
}
return level;
}
bool isOperator(char op)//判斷輸入串中的字元是不是操作符，如果是返回true
{
if(op=='+'||op=='-'||op=='*'||op=='/')
return true;
else
return false;
}
string convert(string s)//將一個中綴串轉換為後綴串，
{
string output="";//輸出串
for(int i=s.length()-1;i>=0;)//1）求輸入串的逆序。
{
if(s[i]>=48&&s[i]<=57)
output=output+s[i];//3）假如是操作數，把它添加到輸出串中。
if(s[i]==')')//4）假如是閉括弧，將它壓棧。
{
top++;
stack[top]=s[i];
}
while(isOperator(s[i]))//如果是運算符，執行演算法(5)對應操作；
{
if(top==0||stack[top]==')'||level(s[i])>=level(stack[top]))
{
top++;
stack[top]=s[i];
break;
}
else
{
output=output+stack[top];
top--;
}
}
if(s[i]=='(')//6）假如是開括弧，棧中運算符逐個出棧並輸出，直到遇到閉括弧。閉括弧出棧並丟棄。
{
while(stack[top]!=')')
{
output=output+stack[top];
top--;
}
top--;
}
i--;//7）假如輸入還未完畢，跳轉到步驟2。
}
while(top!=0)//8）假如輸入完畢，棧中剩餘的所有操作符出棧並加到輸出串中。
{
output=output+stack[top];
top--;
}
return output;
}
int main()
{
string input,output;
cout<<"請輸入串:";
cin>>input;
output=convert(input);
cout<<"後綴串為:";
for(int i=output.length()-1;i>=0;i--)//9）求輸出串的逆序。
cout<<output[i];
cout<<endl;
return 0;
}
❸ 利用堆棧求中綴表達式值
include <malloc.h>
#include <stdio.h>
#include <ctype.h>//判斷是否為字元的函數的頭文件
#define maxsize 100
typedef int elemtype;
typedef struct sqstack sqstack;//由於sqstack不是一個類型 而struct sqstack才是
char ch[7]=;//把符號轉換成一個字元數組
int f1[7]=;//棧內元素優先順序
int f2[7]=;//棧外的元素優先順序
struct sqstack
{
elemtype stack[maxsize];
int top;
};
void Initstack(sqstack *s)
{
s->top=0;
}
void Push(sqstack *s,elemtype x)
{
if(s->top==maxsize-1)
printf("Overflow\n");
else
{
s->top++;
s->stack[s->top]=x;
}
}
void Pop(sqstack *s,elemtype *x)
{
if(s->top==0)
printf("underflow\n");
else
{
*x=s->stack[s->top];
s->top--;
}
}
elemtype Gettop(sqstack s)
{
if(s.top==0)
{
printf("underflow\n");
return 0;
}
else
return s.stack[s.top];
}
elemtype f(char c)
{
switch(c)
{
case '+':
return 0;
case '-':
return 1;
case '*':
return 2;
case '/':
return 3;
case '(':
return 4;
case ')':
return 5;
default:
return 6;
}
}
char precede(char c1,char c2)
{
int i1=f(c1);
int i2=f(c2);//把字元變成數字
if(f1[i1]>f2[i2])//通過原來設定找到優先順序
return '>';
else if(f1[i1]<f2[i2])
return '<';
else
return '=';
}
int Operate(elemtype a,elemtype theta,elemtype b)
{
int sum;
switch(theta)
{
case 0:
sum=a+b;
break;
case 1:
sum=a-b;
break;
case 2:
sum=a*b;
break;
default:
sum=a/b;
}
return sum;
}
EvaluateExpression()
{
char c;
int i=0,sum=0;
int k=1,j=1;//設置了開關變數
elemtype x,theta,a,b;
sqstack OPTR,OPND;
Initstack(&OPTR);
Push(&OPTR,f('#'));//0壓入棧
Initstack(&OPND);
c=getchar();
if(c==ch[2]||c==ch[3]||c==ch[5]||c==ch[6])//先對＋和-的情況忽略和左括弧的情況
{
printf("錯誤1 \n");
k=0;
return 0;
}
if(c==ch[0])
c=getchar();//如果是＋，把它覆蓋
if(c==ch[1])
{
j=0;
c=getchar();//也把－號覆蓋
}
while(c!='#'||ch[Gettop(OPTR)]!='#')
{
if(isdigit(c))
{
sum=0;
while(isdigit(c))
{
if(!j)
{
sum=sum*10-(c-'0');//實現了數字串前面有負號（之前是：sum=-(sum*10)-(c-'0')結果是－12＋13＝21）
}
else
sum=sum*10+(c-'0');
c=getchar();
}
Push(&OPND,sum);//如果還是數字先不壓棧，把數字串轉化成十進制數字再壓棧
j=1;
}
else
if(k)
{
switch(precede(ch[Gettop(OPTR)],c))
{
case'<': Push(&OPTR,f(c));//把它們整型化
c=getchar();
if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//要除去下個是『（』的情況 也把以運算符歸到這里來
{
printf("出錯2\n");
k=0;
return 0;//加了開關變數和返回0的值使程序更以操作
}
break;
case'=': Pop(&OPTR,&x);
c=getchar();
if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//把ch[6]的情況也忽略了但此時並沒有注意到右括弧後面右運算符的情況
{
printf("出錯2\n");
k=0;
return 0;
}
break;
case'>': Pop(&OPTR,&theta);
Pop(&OPND,&b);
Pop(&OPND,&a);//注意這里是誰先出棧
Push(&OPND,Operate(a,theta,b));
break;
}
}
}//在這里判斷是否以運算符結束是不對的
return(Gettop(OPND));
}
main()
{
int result;
printf("輸入你的算術表達式：\n");
result=EvaluateExpression();
printf("結果是 :%d\n",result);
return 0;
}
:
本計算器利用堆棧來實現。
1、定義後綴式計算器的堆棧結構
因為需要存儲的單元不多，這里使用順序棧，即用一維數組來模擬堆棧：
#define MAX 100
int stack[MAX];
int top=0;
因此程序中定義了長度為MAX的一維數組，這里MAX用宏定義為常數100，我們可以修改宏定義而重新定義堆棧的大小。
整型數據top為棧頂指示，由於程序開始時堆棧中並無任何數據元素，因此top被初始化為0。
2、存儲後綴式計算器的運算數
我們定義了堆棧stack[MAX]後，就可以利用入棧操作存儲先後輸入的兩個運算數。
下面看一下是如何實現的：
int push(int i) /*存儲運算數，入棧操作*/
{
if(top<MAX)
{
stack[++top]=i; /*堆棧仍有空間，棧頂指示上移一個位置*/
return 0;
}
else /*堆棧已滿，給出錯誤信息，返回出錯指示*/
{
printf("The stack is full");
return ERR;
}
}
我們在調用函數push時，如果它的返回值為0，說明入棧操作成功；否則，若返回值為ERR(在程序中說明為-1)，說明入棧操作失敗。
3、從堆棧中取出運算數
當程序中讀完了四則運算符後，我們就可以從堆棧中取出已經存入的兩個運算數，構成表達式，計算出結果。取出運算數的函數採用的正是出棧演算法。在本例中，實現該演算法的函數 為pop():
int pop(); /*取出運算數，出棧操作*/
{
int var; /*定義待返回的棧頂元素*/
if(top!=NULL) /*堆棧中仍有數據元素*/
{
var=stack[top--]; /*堆棧指示下移一個位置*/
return var;
}
else /*堆棧為空，給出錯誤信息，並返回出錯返回值*/
printf("The stack is cmpty!\n");
return ERR;
}
同樣，如果堆棧不為空，pop()函數返回堆棧頂端的數據元素，否則，給出棧空提示，並返回錯誤返回值ERR。
4、設計完整的後綴式計算器
有了堆棧存儲運算數，後綴式計算器的設計就很簡單了。程序首先提示用戶輸入第一個運算數，調用push()函數存入堆棧中；而後提示用戶輸入第二個運算數，同樣調用push()函數存入堆棧中。接下來，程序提示用戶輸入+,-,*,/四種運算符的一種，程序通過switch_case結構判斷輸入運算符的種類，轉而執行不同的處理代碼。以除法為例，說明程序的執行流程：
case '/':
b=pop();
a=pop();
c=a/b;
printf("\n\nThe result is %d\n",c);
printf("\n");
break;
程序判斷用戶輸入的是除號後，就執行上述代碼。首先接連兩次調用pop()函數從堆棧中讀出先前輸入的運算數，存入整型數a和b中；然後執行除法運算，結果存入單元c中。這時需要考慮究竟誰是被除數，誰是除數。由於開始我們先將被除數入棧，根據堆棧「先進後出」的原則，被除數應該是第二次調用pop()函數得到的返回值。而除數則是第一次調用pop()函數得到的返回值。
最後程序列印出運算結果，並示提示用戶是否繼續運行程序：
printf("\t Continue?(y/n):");
l=getche();
if(l=='n')
exit(0);
如果用戶回答是"n"，那麼結束程序，否則繼續循環。
完整的程序代碼如下：
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define ERR -1
#define MAX 100 /*定義堆棧的大小*/
int stack[MAX]; /*用一維數組定義堆棧*/
int top=0; /*定義堆棧指示*/
int push(int i) /*存儲運算數,入棧操作*/
{
if(top<MAX)
{
stack[++top]=i; /*堆棧仍有空間，棧頂指示上移一個位置*/
return 0;
}
else
{
printf("The stack is full");
return ERR;
}
}
int pop() /*取出運算數，出棧操作*/
{
int var; /*定義待返回的棧頂元素*/
if(top!=NULL) /*堆棧中仍有元素*/
{
var=stack[top--]; /*堆棧指示下移一個位置*/
return var; /*返回棧頂元素*/
}
else
printf("The stack is empty!\n");
return ERR;
}
void main()
{
int m,n;
char l;
int a,b,c;
int k;
do{
printf("\tAriothmatic Operate simulator\n"); /*給出提示信息*/
printf("\n\tPlease input first number:"); /*輸入第一個運算數*/
scanf("%d",&m);
push(m); /*第一個運算數入棧*/
printf("\n\tPlease input second number:"); /*輸入第二個運算數*/
scanf("%d",&n);
push(n); /*第二個運算數入棧*/
printf("\n\tChoose operator(+/-/*//):");
l=getche(); /*輸入運算符*/
switch(l) /*判斷運算符，轉而執行相應代碼*/
{
case '+':
b=pop();
a=pop();
c=a+b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '-':
b=pop();
a=pop();
c=a-b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '*':
b=pop();
a=pop();
c=a*b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '/':
b=pop();
a=pop();
c=a/b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
}
printf("\tContinue?(y/n):"); /*提示用戶是否結束程序*/
l=getche();
if(l=='n')
exit(0);
}while(1);
}
:
#include <stdio.h>
#include <conio.h>
#include <malloc.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#define STACK_INIT_SIZE 100 //初始分配量
#define STACKINCREMENT 10 //存儲空間的分配增量
typedef char ElemType;
typedef ElemType OperandType; //操作數
typedef char OperatorType;
typedef struct
{
ElemType *base;
ElemType *top;
int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{
//構造一個空棧S
S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
if(!S.base) exit (OVERFLOW);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
Status GetTop(SqStack S){
ElemType e;
if (S.top == S.base) return ERROR;
e = *(S.top-1);
return e;
}
Status Push (SqStack &S,ElemType e)
{
//插入元素e為新的棧頂元素
if (S.top - S.base >= S.stacksize){
S.base = (ElemType *) realloc ( S.base,
(S.stacksize + STACKINCREMENT) * sizeof(ElemType));
if(!S.base) exit (OVERFLOW);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return OK;
}
Status Pop (SqStack &S,ElemType &e){
//若棧不空，則刪除S的棧頂元素，用e返回其值，並返回OK；否則返回ERROR
if(S.top == S.base) return ERROR;
e = * --S.top;
return OK;
}
char In(char c,char OP[])
{
if(c>=35 && c<=47)
return 1;
else return 0;
}
char OP[8]=;
int m[7][7]={1,1,2,2,2,1,1,
1,1,2,2,2,1,1,
1,1,1,1,2,1,1,
1,1,1,1,2,1,1,
2,2,2,2,2,0,-1,
1,1,1,1,-1,1,1,
2,2,2,2,2,-1,0};//1 > 2 < 0 = -1 不存在
char Precede(char i,char j)
{
int a,b; char *p;
for(p=OP,a=0;*p!='\0';p++,a++)
if(*p==i) break;
for(p=OP,b=0;*p!='\0';p++,b++)
if(*p==j) break;
if(m[a][b]==1) return '>';
else if(m[a][b]==2) return '<';
else if(m[a][b]==0) return '=';
else return 'O';
}
char Operate(char a,char theta,char b)
{
if(a>47) a=atoi(&a);
if(b>47) b=atoi(&b);
switch(theta)
{
case '+': return a+b;
break;
case '-': return a-b;
break;
case '*': return a*b;
break;
case '/': return a/b;
break;
}
}
OperandType EvaluateExpression()
{
SqStack OPTR,OPND;
OperandType a,b,c; OperatorType theta;
InitStack(OPTR); Push(OPTR,'#');
InitStack(OPND); c=getchar();
while (c!='#' || GetTop(OPTR)!='#')
{
if (!In(c,OP))
else
switch(Precede(GetTop(OPTR),c))
{
case '<' :
Push(OPTR,c); c = getchar();
break;
case '=' :
Pop(OPTR,c); c = getchar();
break;
case '>' :
Pop(OPTR,theta);
Pop(OPND,b); Pop(OPND,a);
Push(OPND,Operate(a,theta,b));
break;
}
}
return GetTop(OPND);
}
void main()
{
printf("(以#為結束符)\n");
printf("請輸入：\n");
int a;
a=(int)EvaluateExpression();
printf("%d",a);
getch();
}
:
ls都正確
:
C++ In Action這本書裡面有表達式求值的詳細項目分析.
:
數據結構的書裡面都有的,仔細看一下
:
studyall123的只能對0到9的數字運算才有效,對於10以上的數字就不行!不知道有沒有更好的方法!
:
現在的人，連google一下都懶啊
:
實際上是按照逆波蘭式的順序讓輸入的表達式入棧，再根據運算符優先順序來計算。
:
lenrning!
❹ 數據結構：C語言描述棧的應用——算符優先法求中綴表達式的值
#include"iostream.h"
#include"math.h"
#include"stdlib.h"
class Calculator
{
public:
//介面方法聲明
void Run();
private:
//輔助函數
bool IsOperator(char ch);//判斷字元ch是否為操作符
char Precede(char theta1,char theta2);//判斷相繼出現的theta1和theta2的優先順序
double Operate(double left,char theta,double right,int[] &a);//執行運算letf theta right
void Get2Operands(LinkStack<double>&opnd,double &left,double &right);
//從棧opnd中退出兩個操作數
};
void Calculator::Get2Operands(LinkStack <double>&opnd,double &left,double &right)
{
}
bool Calculator:: IsOperator(char ch)
{
char ch;
cin>>ch;
if(ch=='+'||ch=='-'||ch=='*'||ch=='/'ch=='('ch==')'||ch=='=')
return true;
else
return false;
}
char Calculator:: Operate(double left,char theta,double right)
{ double result;
switch(theta)
{
case'+':result=left+right;break;
case'-':result=left-right;break;
case'*':result=left*right;break;
case'/':result=left/right;break;
}
return result;
}
char Calculator:: Precede(char theta1,char theta2)
{
char ch;
switch(theta1)
{
case'+':
case'-':
{
switch (theta2)
{
case'+':
case'-':
case')':
case'=':
ch='>';
break;
case'*':
case'/':
case'(':
ch='<';
break;
}
break;
}
case'*':
case'/':
{
if(theta2=='(')
ch='<';
else
ch='>';
break;
}
case'(':
{
if(theta2==')')
ch='=';
else ch='<';
break;
}
case')':
{
ch='>';
break;
}
case'=':
{
if(theta2=='=')
ch='=';
else
ch='<';
break;
}
}
return ch;
}
//方法Run()演算法實現如下
void Calculator::Run()
{//操作結果:按算符優先法進行表達式求值計算
LinkStack<double> opnd; //操作數棧
LinkStack<char>optr; //操作符棧
optr.push('='); //在optr棧中加入一個'='
char ch; //臨時字元
char optrTop; //臨時optr棧棧頂字元
double operand; //操作數
char theta; //操作符
cin>>ch; //從輸入流獲取一字元ch
while((optr.Top(optrTop),optrTop!='=')||ch!='=')
{
if(!IsOperator(ch))
{//ch不是操作字元
cin.putback(ch); //將字元放ch回輸入流
cin>>operand; //讀操作數operand
opnd.Push(operand); //進入opnd棧
cin>>ch; //讀入下一字元ch
}
else
{//ch是操作符
switch(Precede(optrTop,ch))
{
case'<':
optr.Push(ch);
cin>>ch;
break;
case'=':
optr.Pop(optr Top);
cin>>ch;
break;
case'>':
double left,right;
Get2Operands(opnd,left,right);
optr.Pop(theta);
opnd.Push(Operate(left,theta,right));
break;
case'e':
cout<<"操作符匹配出錯"<<endl;
exit(2);
}
}
}
opnd.Top(operand);
cout<<"表達式值為:"<<operand<<endl;
}
void main(void)
{
system("pause");
return 0;
}
❺ 計算器把中綴表達式轉換為後綴表達式的原理是什麼不要代碼,求解答
假設一個二叉樹以中根順序入棧,從棧結構看:
1.入棧前輸出結果:前綴表達
2.第一次出棧時輸出:中綴表達
3.第二次出棧時輸出:後綴表達
入棧演算法:
void visit{Node p)
while (p!=null){
(1)
push(p);
visit(p.left);
pop(p);
(2)
push(p);
visit(p.right);
pop(p);
(3)
}
}
分別在(1)(2)(3)處輸出可得到前根,中根和後根遍歷
對我有用[0] 丟個板磚[0] 引用 | 舉報 | 管理
關注
antimatterworld
antimatterworld
等級：
#6 得分：0回復於： 2009-03-19 10:58:28
樓上仁兄厲害
俺再研究研究...
對我有用[0] 丟個板磚[0] 引用 | 舉報 | 管理
關注
ToBeTough
ToBeTough
等級：
#7 得分：0回復於： 2009-03-20 07:20:22
引用 5 樓 njwangchuan 的回復:假設一個二叉樹以中根順序入棧,從棧結構看:
1.入棧前輸出結果:前綴表達
2.第一次出棧時輸出:中綴表達
3.第二次出棧時輸出:後綴表達
入棧演算法:
void visit{Node p)
while (p!=null){
(1)
push(p);
visit(p.left);
pop(p);
(2)
push(p);
visit(p.right);
pop(p);
(3)
}
}
分別在(1)(2)(3)處輸出可得到前根,中根和後根遍…
❻ C語言問題 用一個棧來存符號把數學的中綴表達式計算出來
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAX 100
typedef struct
{
int data[MAX];
int top;
}SeqStack;
SeqStack *Init_SeqStack() //初始化堆棧
{
SeqStack *s;
s=new SeqStack; //申請棧空間
if (!s)
{
printf("空間不足，初始化失敗！");
return NULL; //未申請到足夠大的存儲空間，返回空指針
}
else
{
s->top=-1; //初始化棧頂指針
printf("堆棧初始化成功!\n按回車鍵繼續...");
return s; //申請到棧空間，返回棧空間地址
}
}
int Empty(SeqStack *s){ //判空棧
if (s->top==-1)
return 1; //棧頂指針指向棧底，空棧
else
return 0;
}
int Push(SeqStack *s,int x){ //進棧
if (s->top==MAX-1)
return 0; //棧滿不能入棧，返回錯誤代碼0
else
{ s->top++; //棧頂指針向上移動
s->data[s->top]=x; //將x至入新的棧頂
return 1; //入棧成功，返回成功代碼1
}
}
int Pop(SeqStack *s,int *x){ //出棧
if (Empty(s))
return 0; //棧空不能出棧，返回錯誤代碼0
else
{ *x=s->data[s->top]; //保存棧頂元素值
s->top--; //棧頂指針向下移動
return 1; //返回成功代碼1
}
}
int GetTop(SeqStack *s) //取棧頂元素
{
return(s->data[s->top]);
}
int Is_OPND(char x)//判斷運算符和運算數
{
int temp;
temp=1;
switch (x)
{
case '^':
case '*':
case '/':
case '%':
case '+':
case '-':
case '(':
case ')':
case '#':temp=0;
}
return(temp);
}
int Precede(char in,char out)
{
int c_temp1,c_temp2;
int temp;
switch(in)
{
case '^':c_temp1=5;break;
case '*':
case '/':
case '%':c_temp1=4;break;
case '+':
case '-':c_temp1=2;break;
case '(':c_temp1=0;break;
case ')':c_temp1=6;break;
case '#':c_temp1=-1;
}
switch(out)
{
case '^':c_temp2=5;break;
case '*':
case '/':
case '%':c_temp2=3;break;
case '+':
case '-':c_temp2=1;break;
case '(':c_temp2=6;break;
case ')':c_temp2=0;break;
case '#':c_temp2=-1;
}
if (c_temp1<c_temp2) temp=-1;//棧外算符優先順序高，入棧
if (c_temp1==c_temp2) temp=0;
if (c_temp1>c_temp2) temp=1;//棧內算符優先順序高，運算
return(temp);
}
int Execute(int a, char op, int b){
int s;
switch(op){
case '^':s=(int)pow(a,b);break;
case '*':s=a*b;break;
case '/':s=a/b;break;
case '%':s=a%b;break;
case '+':s=a+b;break;
case '-':s=a-b;break;
}
return(s);
}
void main()
{
SeqStack *OPTR, *OPND;//定義兩個棧
int w,op,temp;
int a,b,is_err;
OPTR=Init_SeqStack(); //初始化運算符optr堆棧
OPND=Init_SeqStack(); //初始化運算數opnd堆棧
is_err=Push(OPTR,'#'); //首先將#進運算符棧
system("cls");
printf("------------------中綴表達式求值程序------------------\n\n");
printf("-----使用方法：連續輸入表達式，以#號結束，最後按回車鍵。\n\n");
printf("-----可使用的運算符包括：(、)、^、*、/、%、+、-\n\n");
printf("-----注意：運算數為0-9十個數字。\n\n");
printf("-----請輸入表達式：");
w=getchar();
while(w!='#'||GetTop(OPTR)!='#')//算符棧頂元素不是#（表達式非0，執行語句）
{
if (Is_OPND(w))//w為數值，返回1，w為算符，返回0
{
Push(OPND,w-'0');//數值進opnd堆棧
w=getchar();//循環
}
else
switch(Precede(GetTop(OPTR),w))//否則，比較optr堆棧中棧頂的算符與getchar()函數讀入的算符的優先順序
{
case -1://棧外算符優先順序高，繼續入棧
is_err=Push(OPTR,w);//入棧操作
w=getchar();//循環
break;
case 0://???
is_err=Pop(OPTR,&temp);
w=getchar();
break;
case 1://棧內算符優先順序高
is_err=Pop(OPND,&b);//將棧頂的元素賦予後一個變數
is_err=Pop(OPND,&a);
is_err=Pop(OPTR,&op);
is_err=Push(OPND,Execute(a,op,b));
break;
}
}
printf("-----結果為：%d\n",GetTop(OPND));
加分
❼ 棧表示中綴表達式轉後綴表達式
內存中的兩種存儲區
1..棧的特點是 容量小 速度快 適合存放小型數據 如基本數據類型和對象類型的引用
在棧中變數直接指向存放變數值的空間 對於對象引用則存放對象在堆中的內存地址
2..堆的特點和棧相反 因此適合存放對象本身
3..對象引用訪問對象的原理是 先通過該引用找到棧中的數據 即對象的地址 在通過該
地址訪問對象 這就是為什麼 對象 a=null; 調用a.方法(屬性) 會引發異常 因為找不到
實際對象的地址 向一個不存在的對象發送消息 如同叫一個不存在的人去幫你做事
程序不崩潰才怪
❽ c++用棧編寫一個中綴表達式轉換為前綴表達式的程序
#include<string>
#include<iostream>
using namespace std;
char stack[50];//定義順序棧，其中第一個元素表示棧為空；
int top=0;//棧頂指針，為0表示棧為空；
int level(char op)//判斷運算符級別函數；其中* /的級別為2，+ -的級別為1；
{
int level;
switch(op)
{
case'+':
case'-':level=1; break;
case'*':
case'/':level=2; break;
default:level=0;break;
}
return level;
}
bool isOperator(char op)//判斷輸入串中的字元是不是操作符，如果是返回true
{
if(op=='+'||op=='-'||op=='*'||op=='/')
return true;
else
return false;
}
string convert(string s)//將一個中綴串轉換為後綴串，
{
string output="";//輸出串
for(int i=s.length()-1;i>=0;)//1）求輸入串的逆序。
{
if(s[i]>=48&&s[i]<=57)
output=output+s[i];//3）假如是操作數，把它添加到輸出串中。
if(s[i]==')')//4）假如是閉括弧，將它壓棧。
{
top++;
stack[top]=s[i];
}
while(isOperator(s[i]))//如果是運算符，執行演算法(5)對應操作；
{
if(top==0||stack[top]==')'||level(s[i])>=level(stack[top]))
{
top++;
stack[top]=s[i];
break;
}
else
{
output=output+stack[top];
top--;
}
}
if(s[i]=='(')//6）假如是開括弧，棧中運算符逐個出棧並輸出，直到遇到閉括弧。閉括弧出棧並丟棄。
{
while(stack[top]!=')')
{
output=output+stack[top];
top--;
}
top--;
}
i--;//7）假如輸入還未完畢，跳轉到步驟2。
}
while(top!=0)//8）假如輸入完畢，棧中剩餘的所有操作符出棧並加到輸出串中。
{
output=output+stack[top];
top--;
}
return output;
}
int main()
{
string input,output;
cout<<"請輸入串:";
cin>>input;
output=convert(input);
cout<<"後綴串為:";
for(int i=output.length()-1;i>=0;i--)//9）求輸出串的逆序。
cout<<output[i];
cout<<endl;
return 0;
}
自己編譯吧
❾ 使用棧計算表達式的值（用中綴表達式）數據結構 C++版寫，急！!
我們現在所寫的表達值就是中綴。
中綴難啊。後綴就寫了一個，只不過是C版的。
❿ 寫出對應的中綴算術表達式
(24+8)*3/4*(10-7)