栈应用：中序表达式转为先序表达式

main.cpp

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "stack_op.h"
#include "stack.h"
#include <iostream>
#define MAXNUM 100
using namespace std;
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;

void CrtExptree(BiTree &T, char exp[] );//以表达式字符串的形式建立一颗表达式二叉树,(a+b)*c-d/e
void PreOrder (BiTree T,void( *visit)(TElemType& e));//先根遍历
void InOrder (BiTree T,void( *visit)(TElemType& e));//中根遍历
void PostOrder (BiTree T,void( *visit)(TElemType& e));//后根遍历
void visit(TElemType& e);//访问函数
void CrtNode(BiTree& T,char ch);//建立叶子节点
void CrtSubtree (BiTree& T, char c);//建立子树
Status IN(char ch,char OP[]);//看ch是否属于OP，如果是返回TRUE，否则返回ERROR
Status precede(char c,char ch);//比较运算符c和ch的优先级,c高于ch返回true，否则返回FALSE

using namespace std;
char OP[]={'+','-','*','/','\0'};
SqStack1 S;
SqStack PTR;
void CrtExptree(BiTree &T, char exp[]) {
	InitStack(S);  Push(S, '#');  InitStack(PTR); 
	char *p = exp;  char ch = *p;
	char c;
	while (!(GetTop(S) =='#' && ch == '#')) {
		BiTree t;
		if (!IN(ch, OP)&&ch!='#'&&ch!='('&&ch!=')')	
			CrtNode( t, ch );
		else {
			switch (ch) {
				case '(' :	
					Push(S, ch); 
					break;
				case ')' :	
					Pop(S, c);
					while (c!='(') {
						CrtSubtree(t, c);
						Pop(S, c);
					}
					break; 
				default:
					while(GetTop(S, c) && c!='('&& precede(c,ch)){ 
						CrtSubtree( t, c);
						Pop(S, c);
					}
					if ( ch!='#') 
						Push( S, ch); 
					break;
			} // switch
		} //else
		if ( ch!='#') { p++;  ch = *p;}
	} // while
	Pop(PTR,T);
} //(a+b)*c-d/e
void CrtNode(BiTree& T,char ch)
{
    T=(BiTNode*)malloc(sizeof(BiTNode));
    T->data = ch;
    T->lchild = T->rchild = NULL;
    Push( PTR, T );
}
void CrtSubtree (BiTree& T, char c)
{
   BiTree lc,rc;
   T=(BiTNode*)malloc(sizeof(BiTNode));
   T->data = c;
   Pop(PTR, rc);  T->rchild = rc;
   Pop(PTR, lc);  T->lchild = lc;
   Push(PTR, T);
}

void PreOrder (BiTree T,void( *visit)(TElemType& e))
{ 
   if (T) {
      visit(T->data);           
      PreOrder(T->lchild, visit); 
      PreOrder(T->rchild, visit);
   }
}
void InOrder (BiTree T,void( *visit)(TElemType& e))
{ 
   if (T) {
      InOrder(T->lchild, visit); 
      visit(T->data);         
      InOrder(T->rchild, visit);
   }
}
void PostOrder (BiTree T,void( *visit)(TElemType& e))
{ 
   if (T) {
      PostOrder(T->lchild, visit);
      PostOrder(T->rchild, visit); 
	  visit(T->data);
   }
}
void visit(TElemType& e){
	cout<<e;
}
Status IN(char ch,char OP[]){
	for(int i = 0;OP[i]!='\0';i++){
		if(ch == OP[i]) return TRUE;
	}
	return FALSE;
}
Status precede(char c,char ch){
	
	int i=0,j=0;
	int pre[5][5];
	pre[0][0]=1,pre[0][1]=1,pre[0][2]=0,pre[0][3]=0,pre[0][4]=1;
	pre[1][0]=1,pre[1][1]=1,pre[1][2]=0,pre[1][3]=0,pre[1][4]=1;
	pre[2][0]=1,pre[2][1]=1,pre[2][2]=1,pre[2][3]=1,pre[2][4]=1;
	pre[3][0]=1,pre[3][1]=1,pre[3][2]=1,pre[3][3]=1,pre[3][4]=1;
	pre[4][0]=0,pre[4][1]=0,pre[4][2]=0,pre[4][3]=0,pre[4][4]=0;
	switch(c){
	case '+':i=0;break;
	case '-':i=1;break;
	case '*':i=2;break;
	case '/':i=3;break;
	case '#':i=4;break;
	}
	switch(ch){
	case '+':j=0;break;
	case '-':j=1;break;
	case '*':j=2;break;
	case '/':j=3;break;
	case '#':j=4;break;
	}
	return pre[i][j];
}

int main(){
	BiTree T;
	char exp[MAXNUM];
	cout<<"input an expression ended by # such as '(a+b)*c-d/e#':"<<endl;
	cin>>exp;
	CrtExptree(T,exp);
	cout<<"sucess and the PreOrder is:"<<endl;
	PreOrder(T,visit);
	cout<<"\nthe PostOrder is:"<<endl;
	PostOrder(T,visit);
	cout<<endl;
	return 0;
}

stack.h

#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
#define  STACK_INIT_SIZE  100
#define  STACKINCREMENT   10

typedef char TElemType;
typedef struct BiTNode { // 结点结构
    TElemType      data;
    struct BiTNode  *lchild, *rchild; // 左右孩子指针                                  
} BiTNode, *BiTree;
typedef  BiTree SElemType, ElemType;
typedef struct {
  SElemType  *base;    
  SElemType  *top;  
  int  stacksize;    
} SqStack,Stack;

Status InitStack (SqStack &S);//初始化栈
Status Push (SqStack &S, SElemType e);//入栈
Status Pop (SqStack &S, SElemType &e);//出栈
Status StackEmpty(SqStack S);//判是否为空栈
Status GetTop(SqStack &S, SElemType &e);//获取栈顶元素

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 Push (SqStack &S, SElemType 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, SElemType &e) {//出栈
     // 若栈不空，则删除S的栈顶元素，
     // 用e返回其值，并返回OK；
     // 否则返回ERROR
    if (S.top == S.base) return ERROR;
    e = *--S.top;
    return OK;
}
 Status StackEmpty(SqStack S){//判栈空
	 if(S.base == S.top) return TRUE;
	 return FALSE;
 }

 Status GetTop(SqStack &S, SElemType &e){//获取栈顶元素
	//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
	if(S.top == S.base) return ERROR;
	e = *(S.top-1);
	return OK; 
 }

stack_op.h

#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
#define  STACK_INIT_SIZE  100
#define  STACKINCREMENT   10
#define OVERFLOW -1
typedef  char SElemType1, ElemType1;
typedef struct {
  SElemType1  *base;    
  SElemType1  *top;  
  int  stacksize;    
} SqStack1,Stack1;

Status InitStack (SqStack1 &S);//初始化栈
Status Push (SqStack1 &S, SElemType1 e);//入栈
Status Pop (SqStack1 &S, SElemType1 &e);//出栈
Status StackEmpty(SqStack1 S);//判是否为空栈
Status GetTop(SqStack1 &S, SElemType1 &e);//获取栈顶元素到e中
SElemType1 GetTop(SqStack1 &S);//返回栈顶元素

Status InitStack (SqStack1 &S)
{// 构造一个空栈S
  S.base=(ElemType1*)malloc(STACK_INIT_SIZE*sizeof(ElemType1));
   if (!S.base) exit (OVERFLOW); //存储分配失败
   S.top = S.base;
   S.stacksize = STACK_INIT_SIZE;
   return OK;
}
 Status Push (SqStack1 &S, SElemType1 e) {//入栈
   if (S.top - S.base >= S.stacksize) {//栈满，追加存储空间
      S.base = (ElemType1 *) realloc ( S.base,
                (S.stacksize + STACKINCREMENT) * sizeof (ElemType1));
       if (!S.base) exit (OVERFLOW); //存储分配失败
       S.top = S.base + S.stacksize;
       S.stacksize += STACKINCREMENT;
   }
   *S.top++ = e;
    return OK;
}
 Status Pop (SqStack1 &S, SElemType1 &e) {//出栈
     // 若栈不空，则删除S的栈顶元素，
     // 用e返回其值，并返回OK；
     // 否则返回ERROR
    if (S.top == S.base) return ERROR;
    e = *--S.top;
    return OK;
}
 Status StackEmpty(SqStack1 S){//判栈空
	 if(S.base == S.top) return TRUE;
	 return FALSE;
 }

 Status GetTop(SqStack1 &S, SElemType1 &e){//获取栈顶元素1
	//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
	if(S.top == S.base) return ERROR;
	e = *(S.top-1);
	return OK; 
 }

  SElemType1 GetTop(SqStack1 &S){//返回栈顶元素2
	//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
	if(S.top == S.base) return NULL;
	SElemType1 e = *(S.top-1);
	return e; 
 }