栈的实际应用----中缀表达式转后缀表达式

我们把平时所用的标准四则运算表达式，即“9+（3-1）*3+10 / 2”叫做中缀表达式。
中缀表达式 “9+（3-1）*3+10 / 2” 转化为后缀表达式 “ 9 3 1 - 3 * + 10 2 / + ”
规则：
从左到右遍历中缀表达式的每个数字和符号；
①. 若是数字就输出，即成为后缀表达式的一部分；
②. 若是符号，则判断其与栈顶符号的优先级；
如果当前符号是右括号，则依次输出栈顶符号，直到左括号（注意不输出左右括号）；
如果当前符号的优先级低于栈顶符号，则一直输出栈顶符号，直到优先级低于当前符号，则将当前符号入栈；
如果栈为空栈或者当前符号的优先级高于栈顶元素，则将当前符号入栈。遍历结束后将栈中符号全部出栈并输出；

本代码加入了#作为一个数字的分割线，便于后缀表达式的计算

代码演示：

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

#define ElemType char

//栈结点类型
typedef struct StackNode
{
	ElemType data;
	struct StackNode* next;
}StackNode, * PStackNode;

//栈类型
typedef struct stack
{
	int size;
	PStackNode top;
}Stack, * PStack;

//初始化栈
PStack InitStack()
{
	PStack stack = (PStack)malloc(sizeof(Stack));
	stack->size = 0;
	stack->top = NULL;
	return stack;
}

//压栈，头插法
void Push(PStack stack, ElemType e)
{
	PStackNode newNode = (PStackNode)malloc(sizeof(StackNode));
	newNode->data = e;
	newNode->next = stack->top;
	stack->top = newNode;
	stack->size++;
	return;
}

//出栈
void Pop(PStack stack, ElemType* e)
{
	if (stack == NULL || stack->top ==NULL)
	{
		return;
	}

	*e = stack->top->data;
	PStackNode temp = stack->top->next;
	free(stack->top);
	stack->top = temp;
	stack->size--;
	return;
}

//获取栈顶元素
ElemType GetTop(PStack stack)
{
	if (stack != NULL && stack->top != NULL)
	{
		return stack->top->data;
	}
	return '\0';
}

//比较两个字符的优先级
int Precede(char a, char b)
{
	//栈顶元素优先级较高则返回1，出栈，否则返回-1，进栈，栈顶元素不可能是右括号
	switch (a)
	{
	case '+':
	case '-':
		if (b == '+' || b == '-')//出栈
			return 1;
		else
			return -1;
		break;
	case '*':
	case '/':
		if (b == '(')
			return -1;
		else
			return 1;
		break;
	case '(':
			return -1;
		break;
	default:
		break;
	}
	return 0;
}

int main(int argc, char* argv[])
{
	PStack stack = InitStack();
	char buff[100];
	scanf("%s", buff);
	int i = 0;
	char e;
	for (i = 0; i < strlen(buff); i++)
	{
		//添加了#,便于将数字字符转换成整型数字
		if ((buff[i] >= '0' && buff[i] <= '9') && (buff[i+1] >= '0' && buff[i+1] <= '9'))
		{
			printf("%c", buff[i]);
		}
		else if ((buff[i] >= '0' && buff[i] <= '9') && (buff[i + 1] < '0' || buff[i + 1] > '9'))
		{
			printf("%c#", buff[i]);
		}
		else if (buff[i] == ')')//一直出栈到左括号
		{
			while (stack->top->data != '(')
			{
				if (stack->top->data != '(')
				{
					Pop(stack, &e);
					printf("%c", e);
				}
			}
			//把左括号出栈
			Pop(stack, &e);
		}
				//当栈顶元素优先级较低时，把当前元素压栈
		else if (stack->top == NULL || Precede(stack->top->data, buff[i]) < 0)
		{
			Push(stack, buff[i]);
		}

		//当栈顶符号优先级较高时，一直出栈，最后把当前符号压栈
		else if (Precede(stack->top->data, buff[i]) > 0)
		{
			//如果栈中元素全部出栈，则不能对栈顶元素进行访问
			while (stack->top != NULL && Precede(stack->top->data, buff[i]) > 0)
			{
				Pop(stack, &e);
				printf("%c", e);//输出栈顶符号
			}
			//把当前符号进栈
			Push(stack, buff[i]);
		}

	}

	while (stack->top != NULL)
	{
		Pop(stack, &e);
		printf("%c", e);
	}
	printf("\n");

	return 0;
}

输出结果：