逆波兰法求算术运算结果

逆波兰法求算术运算结果（PS:只能求±*/四则运算）
1）首先是中缀转后缀
遇到数字输出，遇到符号入栈，若要入栈的符号的优先级小于栈顶符号，则栈中优先级大于该符号的所有符号都出栈，然后该符号入栈。

2）后缀表达式求值
遇到数字入栈，入到符号，则将相应的两个数出栈进行计算
RPN.c

#include<stdio.h>
#include<stdlib.h>
#include"linknode.h"
#include<string.h>

void main()
{	
	int brace;
	int result;
	int len,i,j;//数组长度，计数器
	char equ[MAXSIZE] ="9+2*(6-9)+3";
	char infexa[MAXSIZE]={'\0'};//中缀数组
	printf("the origin expression is:\n",equ);

	strcpy(infexa,convert(equ));//后缀转中缀

	printf("infex expression is:%s\n",infexa);

	//后缀计算表达式
	result = calculate(infexa);
	printf("the result is:%d\n",result);
	system("pause");
}

linknode.h

#define MAXSIZE 20
#define datatype char//预编译不用;
#define format "%c,%p,%p\n"


typedef struct stacknode//定义struct stacknode 类型 结点的结构体
{
	datatype num;//存放字符型数据（数字和符号）
	struct stacknode * next;
}stacknode,*stacknodep;

typedef struct stack
{
	stacknodep top;//指向栈顶
	int count;//计数
}stack,*stackp;


void init(stackp head);//初值化栈

int isempty(stackp head);//检查栈是否为空

void push(stackp head,datatype data);//将数据压入栈中

void pop(stackp head,datatype * datap);//出栈

void showstack(stackp head);//显示栈

int isdigit(char input);//判断是否为数字

char * convert(char *  equ);//中缀转后缀

int calculate(char *infexa);//后缀表达式，计算结果

linknode.c

#include"linknode.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void init(stackp head)//初值化栈
{
	head->top = NULL;//指向0
	head->count =0;//表示没有元素
}

int isempty(stackp head)//判断栈是否为空
{
	if(head->top == NULL&& head ->count == 0)
	{
		return 0;//空栈
	}
	else
		return 1;
}

void push(stackp head,datatype data)//将数据压入栈中
{
	stacknodep  newnode;
	if(head->count==MAXSIZE)//满栈
	{
		printf("the stack is full\n");
		return;
	}
	else if(head->count==0)
	{
		newnode = (stacknodep)malloc(sizeof(stacknode));//开辟空间，创建结点
		newnode->num = data;//初始化结点
		newnode->next = NULL;
		head->top = newnode;//指向栈顶
		head->count++;
		return;
	}
	else
	{
		newnode = (stacknodep)malloc(sizeof(stacknode));
		newnode->num = data;//初值化结点
		newnode->next = head->top;//建立链接关系
		head->top = newnode;//指向栈顶
		head->count++;
		return;
	}

}

void showstack(stackp head)//显示栈
{
	stack label1;
	label1.top = head->top;
	label1.count = head->count;
	if (label1.top==NULL&&label1.count==0)
	{
		return;
	}
	else 
	{
		while(label1.top!=NULL)
		{
			printf(format,label1.top->num,label1.top,label1.top->next);
			label1.top = label1.top->next;//向栈底推进
			label1.count--;
		}
		//return;
	}
}

void pop(stackp head,datatype * datap)//出栈
{
	stacknodep p1;
	if (head->top==NULL&&head->count==0)
	{
		printf("the stack has been empty\n\n");
		return;
	}
	else
	{
		*datap = head->top->num;//传递出栈数据
		p1 = head->top;
		head->top = head->top->next;
		free(p1);
		head->count--;
	}
}

int isdigit(char input)//判断是否为数字
{
	if(input>='0'&&input<='9')
	{
		return 1;
	}
	else
		return 0;

}

char * convert(char *  equ)//中缀转后缀
{   

	int brace;//记录'('的个数
	int len,i,j;//数组长度，计数器
	char infexa[MAXSIZE]={'\0'};//中缀数组
	stack sign,temp;
	stackp signp;


	signp = & sign;

	init(signp);//初值化栈
	len =strlen(equ);

	j=0;
	brace =0;
	for(i=0;i<len;i++)
	{
		if(isdigit(equ[i]))
		{
			infexa[j]=equ[i];//遇到数字输出数字
			j++;
		}
		else
		{
			if(signp->top==NULL)//空栈
			{	
				push(signp,equ[i]);//符号进栈
			}
			else if(equ[i]=='(')
			{
				push(signp,equ[i]);//'('入栈
				brace++;//记录左括号的个数
			}
			else if (brace>=1)//有多于一个
			{
				if (equ[i]==')')
				{

					while(signp->top->num!='(')//输出到'('
					{
				        pop(signp,&infexa[j]);
						j++;
					}
					temp.top = signp->top;//删除‘)’
					signp->top=signp->top->next;
					free(temp.top);
					brace--;
				}
				else
				{
					push(signp,equ[i]);
				}
			}
			else
			{
				if (equ[i]=='+'||equ[i]=='-')
				{

						while(signp->top!=NULL)
						{
							pop(signp,&infexa[j]);
							j++;
						}
						push(signp,equ[i]);
				
				}

				else if(equ[i]=='*'||equ[i]=='/')
				{
					if (signp->top->num=='+'||signp->top->num=='-')//若栈顶为低优先级符号
					{
						push(signp,equ[i]);
					}
					else
					{
						while(signp->top->num=='*'||signp->top->num=='/')
						{
							pop(signp,&infexa[j]);
							j++;
						}
						push(signp,equ[i]);
					}
				}
			}

			}
		

		
	}
	pop(signp,&infexa[j]);//对输入完成扫描后输出最后的符号
	return infexa;
}

int calculate(char *infexa)//后缀表达式，计算结果
{
	int len,i,j;//数组长度，计数器
	int num1,num2,num3;
	int temp[MAXSIZE];//缓存中间结果

	len =strlen(infexa);
	j=0;
	for(i=0;i<len;i++)//扫描后缀表达式数组
	{
		if(isdigit(infexa[i]))
		{
			temp[j]=infexa[i]-48;
			j++;
		}
		else
		{
			switch(infexa[i])
			{
				case '+':
				{
					num1 = temp[--j];
					num2 = temp[--j];
					num3 = num2 + num1;
					temp[j] = num3;
					j++;
					break;
				}
				case '-':
				{
					num1 = temp[--j];
					num2 = temp[--j];
					num3 = num2 - num1;
					temp[j] = num3;
					j++;
					break;
				}
				case '*':
				{
					num1 = temp[--j];
					num2 = temp[--j];
					num3 = num2 * num1;
					temp[j] = num3;
					j++;
					break;
				}
				case '/':
				{
					num1 = temp[--j];
					num2 = temp[--j];
					num3 = num2 / num1;
					temp[j] = num3;
					j++;
					break;
				}
			}
		}
	}
	return temp[0];
}