栈的应用-后缀表达式求解

# ifndef LINKSTACK_H
# define LINKSTACK_H

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


//链式栈的结点
typedef struct LINKNODE
{
	struct LINKNODE* next;
}LinkNode;

//链式栈
typedef struct LINKSTACK
{
	LinkNode head;
	int size;
}LinkStack;

//初始化函数
LinkStack* Init_LinkStack();
//入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data);
//出栈
void Pop_LinkStack(LinkStack* stack);
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack);
//返回栈元素的个数
int Size_LinkStack(LinkStack* stack);
//清空栈
void Clear_SeqStack(LinkStack* stack);
//销毁
void FreeSpace_SeqStack(LinkStack* stack);

# endif

# include "LinkStack.h"

//初始化函数
LinkStack* Init_LinkStack()
{
	LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
	stack->head.next = NULL;
	stack->size = 0;
	return stack;
}
//入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data)
{
	if(stack == NULL)
	{
		return ;
	}
	if(data == NULL)
	{
		return ;
	}

	data->next = stack->head.next;
	stack->head.next = data;
	stack->size++;
}
//出栈
void Pop_LinkStack(LinkStack* stack)
{
	if(stack == NULL)
	{
		return ;
	}
	if(stack->size == 0)
	{
		return ;
	}
	//第一个有效结点
	LinkNode* pNext = stack->head.next;
	stack->head.next = pNext->next;
	stack->size--;
}
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack)
{
	if(stack == NULL)
	{
		return NULL;
	}
	if(stack->size == 0)
	{
		return NULL;
	}
	return stack->head.next;
}
//返回栈元素的个数
int Size_LinkStack(LinkStack* stack)
{
	if(stack == NULL)
	{
		return -1;
	}
	return stack->size;
}
//清空栈
void Clear_SeqStack(LinkStack* stack)
{
	if(stack == NULL)
	{
		return ;
	}
	stack->head.next = NULL;
	stack->size = 0;

}
//销毁
void FreeSpace_SeqStack(LinkStack* stack)
{
	if(stack == NULL)
	{
		return ;
	}
}

# include "LinkStack.h"

//判断是不是数字
int IsNumber(char c)
{
	return c >= '0' && c <= '9';
}

typedef struct MYNUM
{
	LinkNode node;
	int val;
}MyNum;

//计算
int Caculate(int left, int right, char c)
{
	int ret = 0;
	switch(c)
	{
		case '+':
			ret = left + right;
			break;
		case '-':
			ret = left - right;
			break;
		case '*':
			ret = left * right;
			break;
		case '/':
			ret = left / right;
			break;
		default:
			break;
	}
	return ret;
}

int main(int argc, char *argv[])
{
	//后缀表达式
	char* str = "831-5*+";
	char* p = str;

	//创建栈
	LinkStack* stack = Init_LinkStack();

	while(*p != '\0')
	{
		//如果是数字 直接入栈
		if(IsNumber(*p))
		{
			MyNum* num = (MyNum*)malloc(sizeof(MyNum));
			num->val = *p - '0';
			Push_LinkStack(stack, (LinkNode*)num);
		}
		else
		{
			//先从栈中弹出右操作数
			MyNum* right = (MyNum*)Top_LinkStack(stack);
			int rightNum = right->val;
			Pop_LinkStack(stack);
			free(right);;
			//取出左操作数
			MyNum* left = (MyNum*)Top_LinkStack(stack);
			int leftNum = left->val;
			Pop_LinkStack(stack);
			free(left);

			int ret = Caculate(leftNum, rightNum, *p);
			//结果入栈
			MyNum* num = (MyNum*)malloc(sizeof(MyNum));
			num->val = ret; 
			Push_LinkStack(stack, (LinkNode*)num);
		}
		p++;
	}
	if(Size_LinkStack(stack) == 1)
	{
		MyNum* num = (MyNum*)Top_LinkStack(stack);
		printf("运算结果是:%d\n", num->val);
		Pop_LinkStack(stack);
		free(num);
	}
	//释放栈
	FreeSpace_SeqStack(stack);

	return 0;
}