C表达式生成2叉树

中序表达式构建二叉树(C语言)~

非常感谢你如此热心的帮助！下面是我同学用C++编的，其中删除树用的是你的代码，分享一下：
#include
struct Node
{
char data;
Node *leftchild,*rightchild;
};

class stack
{
Node * *data1;
int top;
int maxize;
public:
stack(int i);
void push(Node *a);
Node *pop();
};
stack::stack(int max)
{
maxize=max;
top=-1;
data1=new Node *[maxize];

}

void stack::push(Node *a)//入栈
{
data1[++top]=a;
}
Node *stack::pop()//出栈
{
if(top<0)
{
return 0;
top--;
}
else
{
return data1[top--];
}
}
Node *fun()//创建二叉树
{
char temp;
stack stack1(100);
cout<<"输入算术表达式"<<endl;
Node *p;


while(cin.get(temp))
{
if(temp=='
') break;
if(temp'z')
{
p=new Node();
p->data=temp;
p->rightchild=stack1.pop();
p->leftchild=stack1.pop();
stack1.push(p);

}
else
{
p=new Node();
p->data=temp;
p->rightchild=0;
p->leftchild=0;
stack1.push(p);


}
}
return stack1.pop();

}
void xianxu(Node *a)//先序遍历
{
if(a!=0)
{
coutdata;
xianxu(a->leftchild);
xianxu(a->rightchild);
}

}
void zhongxu(Node *a)//中序遍历
{
if(a!=0)
{
zhongxu(a->leftchild);
cout data;
zhongxu(a->rightchild);
}
}
void houxu(Node *a)//后序遍历
{
if(a!=0)
{
houxu(a->leftchild);
houxu(a->rightchild);
cout data;
}
}
int Depth (Node *T ) // 返回二叉树的深度
{
int depth1;
if( !T ) depth1 = 0;
else
{
int depthleft = Depth( T->leftchild );
int depthright= Depth( T->rightchild );
depth1 = 1 + (depthleft > depthright ?
depthleft : depthright);
}
return depth1;
}
void funtion(int c,char temp)
{
for(int i=0;i<c;i++)
{
cout<<" ";
}
cout<<temp<<endl;
}

void print(Node *a,int c)//打印二叉树
{
if(a==0) return;
if(a->rightchild)
{
print(a->rightchild,c+1);
}
funtion(c,a->data);
if(a->leftchild)
{
print(a->leftchild,c+1);
}
}
void Tree_Destroy(Node *t) //删除整个树
{
if (t!=0&&t->leftchild!=0)
Tree_Destroy(t->leftchild);
if(t!=0&&t->rightchild!=0)
Tree_Destroy(t->rightchild);
delete t;
}
//主函数
void main()
{
Node *q;
q=fun();
cout<<"先序遍历"<<endl;
xianxu(q);
cout<<endl;
cout<<"中序遍历"<<endl;
zhongxu(q);
cout<<endl;
cout<<"后序遍历"<<endl;
houxu(q);
cout<<endl;
int d=Depth(q);

print(q,d);
Tree_Destroy(q);
}

/*
* 中缀表达式 构建 二叉树
*
* 方法： 每次找到“最后计算”的运算符，作为当前树的根，然后递归处理
* 详见 刘汝佳《算法竞赛入门经典》 P198
*
*/
#include
using namespace std;

const int maxn = 1000;

//每个节点的左右儿子编号
int lch[maxn], rch[maxn];
//节点的字符
char op[maxn];
//节点数
int cnt = 0;

//s的[x, y)作为范围
int buildTree(char *s, int x, int y){
//c1, c2分别记录出现在括号外的最右边的加减号和乘除号
int c1 = -1, c2 = -1, p = 0, u;

//当前表达式长度为1，则直接以此为一棵树
if(y - x == 1){
u = cnt++; //第u个节点
lch[u] = rch[u] = -1;
op[u] = s[x];
return u;
}

//p==0表示在括号外
for(int i=x; i<y; i++){
switch(s[i]){
case '(': p++; break;
case ')': p--; break;
case '+': case '-':
if(p == 0) c1 = i; //p==0说明s[i]不在括号内
break;
case '*': case '/':
if(p == 0) c2 = i;
break;
}
}

if(c1 < 0) c1 = c2; //括号外没有 + 或 - ，则选括号外的 * 或 /
if(c1 < 0) return buildTree(s, x+1, y-1); //括号外也没有* 或 /， 说明表达式被一个括号括住，去括号

u = cnt++;
lch[u] = buildTree(s, x, c1);
rch[u] = buildTree(s, c1+1, y);
op[u] = s[c1];

return u;
}


int main(){




return 0;
}
下面是转的：

包括中缀、后缀、前缀用二叉树表示：

　　　　

2. 需求分析：

（1）功能：表达式可以用二叉树表示，对于简单的四则运算，请实现以下功能

【1】对于任意给出的前缀表达式（不带括号）、中缀表达式（可以带括号）或后缀表达式（不带括号），能够在计算机内部构造出一棵表达式二叉树，并且图示出来（图形的形式）。

【2】对于构造好的内部表达式二叉树，按照用户的要求输出相应的前缀表达式（不带括号）、中缀表达式（可以带括号，但不允许冗余括）或后缀表达式（不带括号）。

提示：所谓中缀表达式中的冗余括号，就是去掉括号后不影响表达式的计算顺序。例如：“（c+b）+a”中的括号是冗余的，可以表示成不冗余的“c+b+a”。

（2）输入输出要求：请输入字符串表达式：

树形二叉树（图形显示）

中缀表达式为：

前缀表达式为：

后缀表达式为：

3. 概要设计：（算法）

分成两部分完成：

【1】前缀、中缀、后缀表达式->二叉树表达式

前缀表达式->二叉树表达式：（a）碰到操作数则把其值赋给相应的新申请的二叉树结点，地址压栈；（b）碰到操作符则把其值赋给相应的新申请的二叉树，并从栈中弹出两个地址，分别作为其右指针和左指针，然后再把其地址压栈，最后一个地址即为二叉树的根结点地址。

中缀表达式->二叉树表达式：把中缀表达式转换成后缀表达式，然后再建立二叉树。

后缀表达式->二叉树表达式：（a）碰到操作数则把其值赋给相应的新申请的二叉树结点，压栈；（b）碰到操作符则把其值赋给相应的新申请的二叉树结点，取栈顶元素，取栈顶元素分别作为右、左节点。开始时用变量root保存。

【1】二叉树表达式->前缀、中缀、后缀表达式

二叉树表达式->前缀表达式：对二叉树表达式进行前序遍历。

二叉树表达式->中缀表达式：对二叉树表达式进行中序遍历，若结点操作符的优先级高于其左或右子树，在打印相应的子树之前先打印开括号，在打印相应的子树最后在打印一个闭括号。

二叉树表达式->后缀表达式：对二叉树表达式进行后序遍历。

建立表达式树就是建立树中的每一个结点，将每一个结点链接起来就是整棵树。而在建立深度低的结点时要将其左右指针指向之前建立的深度比它高一级的结点(如’*’要指向’2’和’3’，而’+’又要指向’*’)。这样我们可以用栈来存放每次建立的结点，按照优先级(表达式为中缀型)或顺序扫描表达式(表达式为波兰式与逆波兰式)建立每一个结点。建立结点的顺序即为表达式求值的顺序。如果扫描到操作数则直接新建一个左右指针为空的结点，并压入结点栈中(存放结点指针)。遇到运算符时首先新建一个结点，然后从栈中依次弹出两个结点，并让新建立的结点的左右指针域指向它们。当所有结点建立完毕时，如果表达式没有错误(这里假设输入表达式正确)，这时栈中应该只剩下一个结点，它就是所建立的表达式的根结点。





4. 详细设计：（具体方法）

首先创建一个节点类TNode：包含操作符oper、左孩子left、右孩子right，isOper（）判断是否为操作符，getOperOrder（）返回运算符op所对应的优先级，freeTree（）程序结束销毁二叉树，postOrder（）先序遍历，preOrder（）后序遍历，inOrder（）中序遍历，ExpTree1（）后缀表达式生成二叉树，ExpTree3（）前缀表达式生成二叉树，ExpTree2（）中后缀表达式生成二叉树，count（）求值函数，paint（）输出函数



附代码：

　　　　

#include
#include
#include
#include
#include
using namespace std;
class TNode//节点类
{ public:
char oper;
TNode *left;
TNode *right;
int s； int t；
TNode()
{ left=right=NULL;
oper=0;
}
TNode(char op)
{ left=right=NULL;
oper=op;}};
bool isOper(char op)//判断是否为运算符
{
char oper[]={'(',')','+','-','*','/','^'};
for(int i=0;i<sizeof(oper);i++)
{ if(op==oper[i])
{
return true;
} }
return false;}

int getOperOrder(char op)//返回运算符op所对应的优先级
{ switch(op)
{ case '(':
return 1;
case '+':
case '-':
return 2;
case '*':
case '/':
return 3;
case '^':
return 4;
default:
//定义在栈中的右括号和栈底字符的优先级最低
return 0;
} }
void freeTree(TNode *&p) //释放树
{ if(p->left!=NULL)
freeTree(p->left);
if(p->right!=NULL)
freeTree(p->right);
delete(p);
cout<<"Memory free "; }

void postOrder(TNode *p) //先序遍历
{ if(p)
{ postOrder(p->left);
postOrder(p->right);
coutoper;
} }

void preOrder(TNode *p) //后序遍历
{ if(p)
{ coutoper;
preOrder(p->left);
preOrder(p->right);
} }

void inOrder(TNode *p)//中序遍历
{ if(p)
{ if(p->left)
{ if(isOper(p->left->oper)
&& getOperOrder(p->left->oper)
oper))
{ cout<<"(";
inOrder(p->left);
cout<<")";
}else{
inOrder(p->left);
} }
coutoper;
if(p->right)
{ if(isOper(p->right->oper)
&& getOperOrder(p->right->oper)
oper))
{ cout<<"(";
inOrder(p->right);
cout<<")";
}else{
inOrder(p->right);
} } } }

void ExpTree1(TNode *&p,string str)//后缀表达式生成二叉树
{stack nodeStack;
char temp;
int i=0;
temp=str[i++];
while(temp!='\0')
{ if(temp!='\0'&&!isOper(temp))//不是运算符，则进栈
{ p=new TNode(temp);//以temp为结点值构造二叉树结点
nodeStack.push(p);
temp=str[i++];}
else
{ p=new TNode(temp);
if(nodeStack.size())
{ p->right=nodeStack.top();//若非空则弹栈并设为结点的右孩子
nodeStack.pop(); }
if(nodeStack.size())
{ p->left=nodeStack.top();//若非空则弹栈并设为结点的左孩子
nodeStack.pop(); }
nodeStack.push(p);
temp=str[i++];
} } }
void ExpTree3(TNode *&p, string str)//前缀表达式生成二叉树
{ stack nodeStack;
char temp;
int i=str.size()-1;
temp=str[i--];
while(temp!='\0')
{ if(temp!='\0'&&!isOper(temp))
{ p=new TNode(temp);//以temp为内容来建立新的结点
nodeStack.push(p);
temp=str[i--];}
else
{ p=new TNode(temp);
if(nodeStack.size())//若栈顶指针所指结点左孩子为空
{ p->left=nodeStack.top(); //则当前结点设置成其左孩子
nodeStack.pop();
} if(nodeStack.size())//若栈顶指针所指结点右孩子为空
{ p->right=nodeStack.top();//则当前结点设置成其右孩子
nodeStack.pop();//栈顶元素左右孩子指针设置完毕弹出 }
nodeStack.push(p);
temp=str[i--];
} } }

void ExpTree2(TNode *&p, string str)//中缀表达式转换成后缀表达式生成二叉树
{ stack a;
char temp;
string Postfixexp="";
int i=0;
temp=str[i++];
while(temp!='\0')
{ if(!isOper(temp))
{ Postfixexp+=temp;
temp=str[i++];}
else if(temp=='(')//进栈
{ a.push(temp);
temp=str[i++];}
else if(temp==')'){
while(a.top()!='(')//脱括号
{ Postfixexp+=a.top();
a.pop();//在碰到开括号和栈为空前反复弹出栈中元素 }
a.pop();
temp=str[i++];
}else if(temp=='+'||temp=='-'||temp=='*'||temp=='/')//出栈{
while(!a.empty()&&a.top()!='('&&getOperOrder(a.top())>=getOperOrder(temp))//若栈非空栈顶不是左括号且栈顶元素优先级不低于输入运算符时，
//将栈顶元素弹出到后缀表达式中，并且str下标加1
{ Postfixexp+=a.top();
a.pop(); }
a.push(temp);
temp=str[i++];
} }
while(!a.empty())
{ Postfixexp+=a.top();
a.pop();
}
ExpTree1(p,Postfixexp); }
void count(TNode *p,int &height,int n)//求值函数
{ if(p->left==NULL&&p->right==NULL)
{ if(n>height)
height=n;}
if(p->left!=NULL)
count(p->left,height,n+1);
if(p->right!=NULL)
count(p->right,height,n+1); }
void paint(TNode *p)//输出函数
{ int height=0;
int h=0;
int i;
using std::queue;
queue aQueue;
count(p,height,1);
TNode *pointer=p;
TNode *lastpointer;
if(pointer)
{ pointer->s=1;
pointer->t=1;
aQueue.push(pointer); }
while(!aQueue.empty())
{ lastpointer=pointer;
pointer=aQueue.front();
aQueue.pop();
if(pointer->s>h)
{cout<<endl;
h=pointer->s;}
if(pointer->t==1)
{for(i=0;is)-1;i++)
cout<<" ";}
else if(lastpointer->s!=pointer->s){
for(i=0;it-1)*(pow(2,height-pointer->s+1)-1)+(pointer->t-1)-1+pow(2,height-pointer->s);i++)
cout<<" "; }
else
{ for(i=0;it-lastpointer->t)*(pow(2,height-pointer->s+1)-1)+(pointer->t-lastpointer->t)-1;i++)
cout<<" "; }
coutoper;
if(pointer->left!=NULL){
pointer->left->s=pointer->s+1;
pointer->left->t=pointer->t*2-1;
aQueue.push(pointer->left);}
if(pointer->right!=NULL){
pointer->right->s=pointer->s+1;
pointer->right->t=pointer->t*2;
aQueue.push(pointer->right);
} } }
int main()
{ string expression;
TNode *tree;
cout<<endl<<"请输入字符串表达式:";
cin>>expression;
if(isOper(expression[0]))
ExpTree3(tree,expression);
else if(isOper(expression[1]))
ExpTree2(tree,expression);
else
ExpTree1(tree,expression);
paint(tree);
cout<<endl;
cout<<"中缀表达式为:";
inOrder(tree);
cout<<endl;
cout<<"前缀表达式为:";
preOrder(tree);
cout<<endl;
cout<<"后缀表达式为:";
postOrder(tree);
cout<<endl;
freeTree(tree);
cout<<endl;
system("pause");
return 0; }

//这是我课程设计中的一题，可以参考一下
//华南农业大学06级Lupkid
//表达式操作数，结果需在int范围内
#include "iostream"
#include "stdlib.h"
#include "stdio.h"
#include "malloc.h"
#include "math.h"
#define STACK_INIT_SIZE 10
#define STACKINCREMENT 5
#define OK 1
using namespace std;
typedef struct {//字符栈
char *base;
char *top;
int stacksize;
}SqStack;
typedef struct {//能存储char型和int型的混合类型,flag为1存储int,flag为0存储int
int data;
char chars;
int flag;
}mixtype;
typedef struct BiTNode {//树结点
mixtype data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;//树类型
BiTree BT;//定义BT树
typedef struct {//能存储数指针的栈
BiTree *base;
BiTree *top;
int stacksize;
}BTStack;
BTStack K1;//树指针栈K1
BTStack K2;//树指针栈K2
SqStack S;//字符栈S
SqStack T;//字符栈T
int InitStack(SqStack &S){//建立字符栈
S.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));
if(!S.base) exit(0);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
int StackEmpty(SqStack &S){//判断字符栈是否空
if(S.top==S.base) return 1;
else return 0;
}
int Push(SqStack &S,char e){//字符进栈
if(S.top-S.base>=S.stacksize){
S.base=(char *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));
if(!S.base) exit(0);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}
int Pop(SqStack &S,char &e){//字符出栈
e=*--S.top;
return OK;
}
char Gettop(SqStack S,char &e){//取栈顶字符
e=*(S.top-1);
return e;
}
char Getbase(SqStack S,char &e){//取栈底元素
e=*S.base;
return e;
}
int InitBTStack(BTStack &S){//建立树指针栈
S.base=(BiTree *)malloc(STACK_INIT_SIZE*sizeof(BiTNode));
if(!S.base) exit(0);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
int BTStackEmpty(BTStack &S){//判断树指针栈是否空
if(S.top==S.base) return 1;
else return 0;
}
int BTPush(BTStack &S,BiTree e){//树指针进栈
if(S.top-S.base>=S.stacksize){
S.base=(BiTree *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(BiTNode));
if(!S.base) exit(0);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}
int BTPop(BTStack &S,BiTree &e){//树指针出栈
e=*--S.top;
return OK;
}
void change(){//中缀表达式转后缀表达式
char a[100];//存储输入的字符
char *p=NULL;//处理字符的指针
char e;
int flag=1;//需要用空格隔开数字的标志,如987+654,9.8.7分别单独进栈T,然后一空格入栈,然后6.5.4分别进T
InitStack(S);//建立S栈
InitStack(T);//建立T栈
cout<<"请输入中缀表达式:";
gets(a);//输入中缀表达式
p=a;
while(*p){
if(*p>='a'&&*p<='z'||*p>='A'&&*p<='Z'||*p>='0'&&*p<='9'){//数字字符或字母进T栈,需要计算结果的之能输入数字
if(*p>='0'&&*p<='9'&&flag==1&&*(p+1)>='0'&&*(p+1)<='9'){//数字情况
flag=1;//数字字符是同一个数中的,flag置1
Push(T,*p);
}
else{//下一个是操作符
flag=0;//flag置0
Push(T,*p);
Push(T,' ');//进一个完整数字后,空格进栈
}
}
else{
if(*p=='('||*p==')'){//左括号或右括号情况
if(*p=='(') Push(S,*p);//左括号进S栈
else{//右括号情况,把S栈中的操作符逐个取出进T栈,直到S栈顶为左括号
while(Gettop(S,e)!='('){
Pop(S,e);
Push(T,e);
Push(T,' ');
}
Pop(S,e);//左括号出S栈
}
}
else{//操作符情况
if(*p=='*'||*p=='/'){//优先级高的乘除法
if(StackEmpty(S)||Gettop(S,e)=='+'||Gettop(S,e)=='-'||Gettop(S,e)=='(') Push(S,*p);//新读入操作符优先级高与栈S顶操作浮或栈S顶为空或栈S顶为左括号,新操作符直接进S栈
else{//新读入操作符优先级与栈S顶操作符相同
while(!StackEmpty(S)&&(Gettop(S,e)=='*'||Gettop(S,e)=='/')){//新读入操作符优先级大于S栈顶操作符,S顶操作符出栈,进T栈,再和S下一栈顶操作符比较,如此循环
Pop(S,e);
Push(T,e);
Push(T,' ');
}
Push(S,*p);//新读入操作符进S栈
}
}
else{//优先级低的加减法
if(StackEmpty(S)||Gettop(S,e)=='(') Push(S,*p);//栈S顶为空或栈S顶为左括号,新操作符直接进S栈
else{//S栈顶操作符和新读入操作符优先级相等，或S栈顶操作符优先级较高
while(!StackEmpty(S)&&((Gettop(S,e)=='+'||Gettop(S,e)=='-')||(Gettop(S,e)=='*'||Gettop(S,e)=='/'))){//新读入操作符优先级小于或等于S栈顶操作符，,S顶操作符出栈,进T栈,再和S下一栈顶操作符比较,如此循环
Pop(S,e);
Push(T,e);
Push(T,' ');
}
Push(S,*p);//新读入操作符进S栈
}
}
}
flag=1;
}
++p;//找到下一字符
}
while(!StackEmpty(S)){//S栈非空则把栈顶元素取出，进T栈
Pop(S,e);
Push(T,e);
Push(T,' ');
}
}
void printf(){//输出后缀表达式
change();
cout<<"后缀表达式为:";
while(T.top!=T.base) cout<<*T.base++; //T栈从底到顶的顺序为后缀表达式
cout<<endl;
}
void creattree(){//建立二叉表达式树
char e;
char a[5];//存储栈中读出的数字字符
int i=0,j;
int sum=0;//暂存重组为int型的数字字符
BiTNode *p=NULL,*q=NULL,*r=NULL;
change();
InitBTStack(K1);
InitBTStack(K2);
while(!StackEmpty(T)){
if(Gettop(T,e)>='0'&&Gettop(T,e)<='9'){//把数字字符重组为int型数
while(Gettop(T,e)!=' '&&!StackEmpty(T)){
Pop(T,e);
a[i]=e;
i++;
}
for(j=0;j<i;j++) sum=(a[j]-'0')*pow(10,j)+sum;
p=(BiTNode *)malloc(sizeof(BiTNode));
p->data.data=sum;
p->data.flag=1;//该结点存储操作数，flag置1
p->lchild=NULL;//操作数z左右子树为NULL
p->rchild=NULL;
i=0;
sum=0;
BTPush(K1,p);//把该结点进树指针栈，目的是把K1栈从栈顶到栈底为后缀表达式
}
else if(Gettop(T,e)==' ') Pop(T,e);//T栈顶为空格直接出栈
else{//T栈顶为操作符，出栈直接存储到新结点
Pop(T,e);
p=(BiTNode *)malloc(sizeof(BiTNode));
p->data.chars=e;
p->data.flag=0;//该结点存储操作符，flag置0
BTPush(K1,p);//把该结点进树指针栈，目的是把K1栈从栈顶到栈底为后缀表达式
}

}
while(!BTStackEmpty(K1)){//连接各结点成为二叉表达式树
BTPop(K1,p);
if(p->data.flag==1) BTPush(K2,p);//结点存储操作数，则进K2栈
else{//结点存储操作符，则把K2栈顶两个结点取出连接起来
BTPop(K2,r);
BTPop(K2,q);
p->lchild=q;
p->rchild=r;
BTPush(K2,p);//已连好的子树进K2栈
}
}
BT=p;//树根
}
int InOrderTraverse(BiTree BT){//中序递归遍历二叉树
if(BT){
InOrderTraverse(BT->lchild);
if(BT->data.flag==1) cout<<BT->data.data;//flag=1,输出操作数
else cout<<BT->data.chars;//flag=0,输出操作符
cout<<" ";
InOrderTraverse(BT->rchild);
}
return 1;
}
int PostOrderTraverse(BiTree BT){//后序扫描操作符,把操作符左右子树进行计算,最终只剩下一个操作数,即二叉表达式树求解
if(BT){
PostOrderTraverse(BT->lchild);
PostOrderTraverse(BT->rchild);
if(BT->data.flag==0){
if(BT->data.chars=='*') BT->data.data=BT->lchild->data.data*BT->rchild->data.data;
else if(BT->data.chars=='/') BT->data.data=BT->lchild->data.data/BT->rchild->data.data;
else if(BT->data.chars=='+') BT->data.data=BT->lchild->data.data+BT->rchild->data.data;
else BT->data.data=BT->lchild->data.data-BT->rchild->data.data;
BT->data.flag=1;
free(BT->lchild);//已算好的操作数释放掉
free(BT->rchild);
BT->lchild=NULL;//已算过的操作符左右子树置空
BT->rchild=NULL;
}
}
return 1;
}
void main(){
int k;
while(1){
cout<<"1.中缀表达式转后缀表达式"<<endl;
cout<<"2.建立二叉表达式树"<<endl;
cout<<"3.利用二叉表达式树求解"<<endl;
cout<<"4.退出"<<endl;
cin>>k;
getchar();//接收回车
switch(k){
case 1:{
printf();
break;
}
case 2:{
creattree();
cout<<"中序遍历为:";
InOrderTraverse(BT);
cout<<endl;
break;
}
case 3:{
PostOrderTraverse(BT);
cout<<"结果为:";
InOrderTraverse(BT);
cout<<endl;
break;
}
case 4:{
exit(0);
}
}
}
}

---

南康市18026566376： 如何将一个表达式转换成二叉树理解表达式a*(b+c) - d的后缀表达式,这个怎么画出二叉树? - ？
冀饲适今：[答案] 表达式生成树的特点为: a. 叶子节点都是操作数; b. 非叶子节点都是运算符; c. 树根的运算符优先级低;步骤如下找到表达式中优先级最低的运算符作为树根(注意括...

南康市18026566376： 用C语言实现二叉树的操作 - ？
冀饲适今： #include#define STACK_MAX_SIZE 30 #define QUEUE_MAX_SIZE 30 #ifndef elemType typedef char elemType; #endif /************************************************************************/ /* 以下是关于二叉树操作的11个简单算法...

南康市18026566376： 求数据结构(C语言版)建立二叉树的代码~~急~~谢谢了 - ？
冀饲适今： BT.H文件 #include <stdio.h> #include <malloc.h> #include <conio.h> #define TRUE 1 #define FALSE 0 #define ERROR 0 #define OK 1 #define Stack_Size 50 #define NUM 50 #define MAXSIZE 50 //队列的最大长度 //定义二叉树 typedef char ...

南康市18026566376： 数据结构中用c语言建立二叉树的程序？
冀饲适今： #include ＂stdio.h＂#include ＂stdlib.h＂#include ＂malloc.h＂typedef struct Bnode //二叉树节点类型{int m; struct Bnode *Lchild,*Rchild;}Btnode, *BTptr; typedef struct Dnode //队列节点类型{ Btnode *pr; struct Dnode *next;}Qnode,*Qlink;typedef ...

南康市18026566376： c语言中缀表达式转换成二叉树,后续周游计算表达式的值 - ？
冀饲适今： #include<stdio.h>#include<stdlib.h>#include<string.h>#define TRUE 1#define FALSE 0#define MAXNUM 1000 typedef int DataType; struct BinTreeNode; typedef struct BinTreeNode*PBinTreeNode; struct BinTreeNode { DataType info; ...

南康市18026566376： 把逻辑表达式转成前缀二叉树 ,c++ 或C 源代码 - ？
冀饲适今： 思路:前缀二叉树表达式就是一个栈,括号的含义就是出栈入栈,所有数据顺序入栈,遇到右括号时开始出栈,直到碰到左括号,中间一段表达式就是作为树节点,其中=> and or等表达式都是非叶节点.伪代码如下:主函数 for (i=0;i<s.size();i+...

南康市18026566376： 数据结构编程 - ？
冀饲适今： 给你写了个利用2叉树的算法,表达式可以构造成2叉树,其实表达式就是2叉树的中序遍历,不懂可以看下数据结构.以下是代码,给你加好了基本注释.此算法先是循环了一遍列表构成2叉树,用的递归,时间复杂度为O(n) #include <stdio.h> ...

南康市18026566376： 数据结构二叉树的创建(c语言版) - ？
冀饲适今： //输入的格式为:abd##e##c###include ＂stdlib.h＂typedef int Element;struct Tree {Element data;struct Tree *left;struct Tree *right; };void CreateBinSortTree(struct Tree **t); void InsertNode2Tree(struct Tree **root, Element num);void ...

南康市18026566376： 前缀表达式怎么转化为二叉树 - ？
冀饲适今： 先把后序式转为中序式,比如 后序:adc*+de/- 中序:a+b*c-d/e 再写前序式:+a-*cbed 需要主意的是前序式是从右往左写,而且要先把结果写进一个栈,写完后再把栈读出来就是前序式了.

南康市18026566376： 二叉树c语言实现 - ？
冀饲适今： #include<iostream.h>#include <stdio.h>#include <stdlib.h> typedef struct node { char data; struct node *lchild,*rchild;// }BiTNode,*BiTree; void CreatBiTree(BiTree &T) { char ch; ch=getchar(); if (ch == ' ') T = 0; else { T=(BiTNode*)malloc(sizeof(...