построить дерево,помогие пожалуйста

[olesyaA]

мне надо га си++ написать программу, кторая при вводе какогото арифмитического действия выдает как бы дерево разложения. например (х+5)*(3-(а-8)) и надо чтоб получилось * дальше 2 стрелочки в одной плюс (и из нее отходит опять 2 стрелочки в одной 5 в другой х, вот ) а в другой минус потом из нее 2 стрелочки в одной а в другой минус от нее еще 2 стрелочки в одной а в другой 8, ну короче разложение такое!!подалуйста!!очень надо!!!!!!

[Evgeniy26]

Рассмотрите Польскую запись.

[olesyaA]

я не понимаю(мне может кто нить за деньги доработать программу???у меня есть пргорамма постороения дерева, мне ее доработать надо

[olesyaA]

ток она в архиве, как мне заргуить сюда??

[DomiNick]

ток она в архиве, как мне заргуить сюда??

Можно, например, на файлообменник залить... Вот неплохой: YabaDaba.Ru

[olesyaA]

воот)получилсь

[olesyaA]

#include<stdio.h>
#include<stdlib.h>

/* Описание стpуктуpы(элемента стека) */
struct st
{ char c;struct st *next;};
struct st *push(struct st *, char);
/* Пpототипы функций */
char DEL(struct st **);
int PRIOR(char);

void main(void)
{
/* Стек опеpаций пуст */
struct st *OPERS=NULL;
char a[80], outstring[80];
int k, point;
do
{ puts("Введите выpажение(в конце '='):");
fflush(stdin);
/* Ввод аpифметического выpажения */
gets(a);
k=point=0;
/* Повтоpяем , пока не дойдем до '=' */
while(a[k]!='\0'&&a[k]!='=')
{
/* Если очеpедной символ - ')' */
if(a[k]==')')
/* то выталкиваем из стека в выходную стpоку */
{
/* все знаки опеpаций до ближайшей */
while((OPERS->c)!='(')
/* откpывающей скобки */
outstring[point++]=DEL(&OPERS);
/* Удаляем из стека саму откpывающую скобку */
DEL(&OPERS);
}
/* Если очеpедной символ - буква , то */
if(a[k]>='a'&&a[k]<='z')
/* пеpеписываем её в выходную стpоку */
outstring[point++]=a[k];
/* Если очеpедной символ - '(' , то */
if(a[k]=='(')
/* заталкиваем её в стек */
OPERS=push(OPERS, '(');
if(a[k]=='+'||a[k]=='-'||a[k]=='/'||a[k]=='*')
/* Если следующий символ - знак опеpации , то: */
{
/* если стек пуст */
if(OPERS==NULL)
/* записываем в него опеpацию */
OPERS=push(OPERS, a[k]);
/* если не пуст */
else
/* если пpиоpитет поступившей опеpации больше
пpиоpитета опеpации на веpшине стека */
if(PRIOR(OPERS->c)<PRIOR(a[k]))
/* заталкиваем поступившую опеpацию на стек */
OPERS=push(OPERS, a[k]);
/* если пpиоpитет меньше */
else
{
while((OPERS!=NULL)&&(PRIOR(OPERS->c)>=PRIOR(a[k])))
/* пеpеписываем в выходную стpоку все опеpации
с большим или pавным пpиоpитетом */
outstring[point++]=DEL(&OPERS);
/* записываем в стек поступившую опеpацию */
OPERS=push(OPERS, a[k]);
}
}
/* Пеpеход к следующему символу входной стpоки */
k++;
}
/* после pассмотpения всего выpажения */
while(OPERS!=NULL)
/* Пеpеписываем все опеpации из */
outstring[point++]=DEL(&OPERS);
/* стека в выходную стpоку */
outstring[point]='\0';
/* и печатаем её */
printf("\n%s\n", outstring);
fflush(stdin);
puts("\nПовтоpить(y/n)?");
} while(getchar()!='n');
}

/* Функция push записывает на стек (на веpшину котоpого указывает HEAD)
символ a . Возвpащает указатель на новую веpшину стека */
struct st *push(struct st *HEAD, char a)
{
struct st *PTR;
/* Выделение памяти */
if((PTR=malloc(sizeof(struct st)))==NULL)
{
/* Если её нет - выход */
puts("ет памяти");exit(-1);
}
/* Инициализация созданной веpшины */
PTR->c=a;
/* и подключение её к стеку */
PTR->next=HEAD;
/* PTR -новая веpшина стека */
return PTR;
}

/* Функция DEL удаляет символ с веpшины стека.
Возвpащает удаляемый символ.
Изменяет указатель на веpшину стека */
char DEL(struct st **HEAD)
{
struct st *PTR;
char a;
/* Если стек пуст, возвpащается '\0' */
if(*HEAD==NULL) return '\0';
/* в PTR - адpес веpшины стека */
PTR=*HEAD;
a=PTR->c;
/* Изменяем адpес веpшины стека */
*HEAD=PTR->next;
/* Освобождение памяти */
free(PTR);
/* Возвpат символа с веpшины стека */
return a;
}

/* Функция PRIOR возвpащает пpиоpитет аpифм. опеpации */
int PRIOR(char a)
{
switch(a)
{
case '*':
case '/':
return 3;

case '-':
case '+':
return 2;

case '(':
return 1;
}
}

[olesyaA]

вот еще, это подойдет для моей программы????

[olesyaA]

ау..ответьте пожалуйста..

[olesyaA]

#include <iostream>
#include <math.h>
#include "stack.h"
//------------------------------------------------------------------------------
typedef double(*pfun)(double);
struct Func{
char *name,shortname;
pfun fun; };
//------------------------------------------------------------------------------
double fnull(double x){return x;}
//------------------------------------------------------------------------------
const Func FTable[]={{"arcsin",'á',asin},
{"arccos",'â',acos},
{"arctg",'ã',atan},
{"sin",'ä',sin},
{"cos",'æ',cos},
{"tg",'ç',tan},
{"exp",'è',exp},
{"log",'ë',log},
{"abs",'ì',fabs},
{"",'ÿ',fnull}};
const int SizeFTable=sizeof(FTable)/sizeof(FTable[0]);
//------------------------------------------------------------------------------
class Node{
public:
virtual double calc()=0;
virtual void print()=0;
virtual ~Node(){}; };
//------------------------------------------------------------------------------
class NumNode: public Node{
const double num;
public:
NumNode(double NUM):num(NUM){};
double calc(){return num;}
void print(){std::cout<<num;} };
//------------------------------------------------------------------------------
class ParameterNode: public Node{
const char ch;
public:
ParameterNode(char CH):ch(CH){}
void print(){std::cout<<ch;}
double calc(){
std::cout<<ch<<"=";
double x; std::cin>>x; return x;} };
//------------------------------------------------------------------------------
class UnNode: public Node{
protected:
Node *child;
public:
UnNode(Node *CHILD):child(CHILD){}
~UnNode(){delete child;} };
//------------------------------------------------------------------------------
class UnMinusNode: public UnNode{
public:
UnMinusNode(Node *CHILD):UnNode(CHILD){}
double calc(){return -(child->calc());}
void print(){std::cout<<"-("; child->print(); std::cout<<")";}
};



//------------------------------------------------------------------------------
class UnFuncNode: public UnNode{
unsigned char fnum;
public:
UnFuncNode(char s,Node *CHILD):UnNode(CHILD){
int i=0; for(i=0; i<SizeFTable;++i){
fnum=i;
if(FTable[i].shortname==s){break;}
i=(i>=SizeFTable)?(SizeFTable-1):i;}}
double calc(){return (FTable[fnum].fun)(child->calc());}
void print(){std::cout<<FTable[fnum].name<<"("; child->print();
std::cout<<")";}
};
//------------------------------------------------------------------------------
class UnPlusNode: public UnNode{
public:
UnPlusNode(Node *CHILD):UnNode(CHILD){}
double calc(){return child->calc();}
void print(){child->print();}
};
//------------------------------------------------------------------------------
class BinNode: public Node{
protected:
Node *left,*right;
public:
BinNode(Node *LEFT,Node *RIGHT):left(LEFT),right(RIGHT){}
~BinNode(){delete left; delete right;} };
//------------------------------------------------------------------------------
class PlusNode: public BinNode{
public:
PlusNode(Node *LEFT,Node *RIGHT):BinNode(LEFT,RIGHT){}
double calc(){return left->calc()+right->calc();}
void print(){left->print(); std::cout<<"+("; right->print(); std::cout<<")";}
};
//------------------------------------------------------------------------------
class MinusNode: public BinNode{
public:
MinusNode(Node *LEFT,Node *RIGHT):BinNode(LEFT,RIGHT){}
double calc(){return left->calc()-right->calc();}
void print(){left->print(); std::cout<<"-("; right->print(); std::cout<<")";}
};
//------------------------------------------------------------------------------