C语言中用链表构建栈讲解,~c语言用链表编写四则运算（最好不用栈）

求助~~~c语言用链表编写四则运算(最好不用栈)

由于之前没学过数据结构，所有没想用链表....

这两天想了两种算法都不好，最后就决定学习链表

烦劳各位大牛啦，让我学习下~~

------解决方案--------------------

之前有看过一个 二叉树的,lz参考一下:

#include

#include

#include

#include

using namespace std;

//树的节点结构体

struct tNode

{

struct tNode *lpL;

struct tNode *lpR;

float Data;

char Operator;

tNode(struct tNode *_L,struct tNode *_R,float _D,char _O):lpL(_L),lpR(_R),Data(_D),Operator(_O){}

};

float GetNum(char *&);//取操作数

char GetOperator(char *&);//取运算符

int GetOperatorKey(char);//取运算符对应优先级表的下标

bool GetPriority(int,int);//取运算符优先级

char *GetBracketsText(char *&);//获取括号中的文本

struct tNode* CreateTree(char *);//创建表达式树

struct tNode *CreateTreeInBrackets(char *&);//创建括号中的表达式树

float CalcTree(struct tNode*);//计算表达式树

//优先级表

bool Priority[5][5]={{0,0,1,1,1},

{0,0,1,1,1},

{0,0,0,0,1},

{0,0,0,0,1},

{0,0,0,0,0}};

float GetNum(char *&src)

{

float f=1.0f;

if ((*src)=='-')

{

src++;

f=-1.0f;

}

char *temp=src;

while ((*src)!='+'&&(*src)!='-'&&(*src)!='*'&&(*src)!='/'&&(*src)!='^'&&(*src)!='\0')

src++;

return atof(temp)*f;

}

char GetOperator(char *&src)

{

char temp=(*src);

src++;

return temp;

}

int GetOperatorKey(char c)

{

switch (c)

{

case '+':

return 0;

case '-':

return 1;

case '*':

return 2;

case '/':

return 3;

case '^':

return 4;

default:

return 0;

}

}

bool GetPriority(int a,int b)

{

a=GetOperatorKey(a);

b=GetOperatorKey(b);

return Priority[a][b];

}

char *GetBracketsText(char *&src)

{

char *temp=strrchr(src,')');

char *ret=new char[temp-src-1];

memcpy(ret,src+1,temp-src-1);

src=temp+1;

return ret;

}

struct tNode *CreateTreeInBrackets(char *&src)

{

char *temp=GetBracketsText(src);

struct tNode *lpTemp=CreateTree(temp);

delete temp;

return lpTemp;

}

struct tNode* CreateTree(char *src)

{

struct tNode *lpNum=(*src=='(')?(CreateTreeInBrackets(src)):(new tNode(NULL,NULL,GetNum(src),0));

struct tNode *lpRoot=NULL;

if (*src)

{

lpRoot=new tNode(lpNum,NULL,0.0f,GetOperator(src));

lpNum=(*src=='(')?(CreateTreeInBrackets(src)):(new tNode(NULL,NULL,GetNum(src),0));

lpRoot->lpR=lpNum;

}

else

return lpNum;

struct tNode *lpMov=lpRoot;

bool Oper=true;

while (*src)

{

if (Oper)

{

char Op=GetOperator(src);

if (GetPriority(lpRoot->Operator,Op))

{

if (lpRoot->lpR->Operator==0)

{

lpMov=new tNode(lpRoot->lpR,NULL,0.0f,Op);

lpRoot->lpR=lpMov;

}

else

{

if (GetPriority(lpRoot->lpR->Operator,Op))

{

lpMov=new tNode(lpRoot->lpR->lpR,NULL,0.0f,Op);

lpRoot->lpR->lpR=lpMov;

}

else

{

lpMov=new tNode(lpRoot->lpR,NULL,0.0f,Op);

lpRoot->lpR=lpMov;

}

}

}

else

{

lpMov=new tNode(lpRoot,NULL,0.0f,Op);

lpRoot=lpMov;

}

Oper=false;

}

else

{

struct tNode *lpTemp=NULL;

if (*src=='(')

lpTemp=CreateTreeInBrackets(src);

else

{

float num=GetNum(src);

lpTemp=new tNode(NULL,NULL,num,0);

}

if (lpMov->lpL)

lpMov->lpR=lpTemp;

else

lpMov->lpL=lpTemp;

Oper=true;

}

}