栈的应用———中缀表达式转后缀表达式

---

一、中缀表达式转后缀表达式规则：

如果是数字，则直接输出
如果是左括号，直接入栈
如果是右括号，出栈，直到遇到第一个左括号
如果是*或者/, 出栈，直到栈空或者左括号或者遇到+ -,当前符号入栈
如果是+或者-，出栈，直到栈空或者左括号，当前符号入栈
如果中缀表达式走完，将栈中的内容全部弹出

二、分布实现

1.如果是数字，直接输出：

代码如下：

if (isdigit(infix[i]))
{
	printf("%c", infix[i]);
	if (!isdigit(infix[i + 1]))
    {
		printf(" ");
	}
}

2.如果是左括号，直接入栈

代码如下：

if (infix[i] == '(')
{
	Push(&st, infix[i]);
}

bool Push(Stack *st, ElemType value)
{
	if (st == NULL) exit(0);

	//如果栈满就扩容
	if (Full(st))
	{
		if (!AppendSpace(st))
		{
			return false;
		}
	}
	//将value的值赋给栈顶元素 
	st->low[st->top++] = value;
	return true;
}

3.如果是右括号，出栈，直到遇到第一个左括号

if (infix[i] == ')')
{
	DealRightPare(&st, infix[i]);
}

static void DealRightPare(Stack *st)
{
	int flag = 0;
	while (!Empty(st))//栈非空
	{
		ElemType value;
		Top(st, &value);//获取栈顶元素
		Pop(st);//入栈

		if (value == '(')
		{
			flag = 1;
			break;
		}
		printf("%c ", value);
	}
	if (!flag)
	{
		printf("Pare is Error!");
	}
}

3.如果是 * 或者 / , 出栈，直到栈空或者左括号或者遇到 + 或者 - ,当前符号入栈

 if (infix[i] == '*' || infix[i] == '/')
{
	DealMultiDiv(&st, infix[i]);
}

static void DealMultiDiv(Stack *st, char ch)
{
	while (!Empty(st))
	{
		ElemType value;
		Top(st, &value);
		if (value == '(' || value == '+'||value == '-') break;
		Pop(st);
		printf("%c ", value);
	}
	Push(st, ch);
}

4.如果是 + 或者 - ，出栈，直到栈空或者左括号，当前符号入栈

else if (infix[i] == '+' || infix[i] == '-')
{
	DealAddSub(&st, infix[i]);
}

static void DealAddSub(Stack *st, char ch)
{
	while (!Empty(st))
	{
		ElemType value;
		Top(st, &value);
		if (value == '(') break;
		Pop(st);
		printf("%c ", value);
	}
	Push(st, ch); 
}

三、测试代码

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

#define INITSIZE  20

typedef char ElemType;

typedef struct Stack
{
	ElemType *low;//栈底指针，存储空间首地址
	ElemType  top;//栈顶
	int size;//栈大小
}Stack;

static bool Full(Stack *st)
{
	return  st->top == st->size;
}

//扩容
static bool AppendSpace(Stack* st)
{
	ElemType *new_space = (ElemType*)malloc(sizeof(ElemType)*st->size * 2);
	if (new_space == NULL) exit(0);

	for (int i = 0; i < st->size; i++)
	{
		new_space[i] = st->low[i];
	}

	free(st->low);
	new_space = st->low;
	st->size *= 2;
	return true;
}

//栈的初始化
void InitStack(Stack *st, int init_size)
{
	if (st == NULL) exit(0);
	
	st->low = (ElemType*)malloc(sizeof(ElemType)*init_size);
	if (st->low == NULL) exit(0);

	st->top = 0;
	st->size = init_size;
}

bool Empty(Stack *st)
{
	if (st == NULL) exit(0);
	return st->top == 0;
}


bool Push(Stack *st, ElemType value)
{
	if (st == NULL) exit(0);

	//如果栈满就扩容
	if (Full(st))
	{
		if (!AppendSpace(st))
		{
			return false;
		}
	}
	//将value的值赋给栈顶元素 
	st->low[st->top++] = value;
	return true;
}

//获取栈顶指针
bool Top(Stack *st, ElemType *value)
{
	if (st == NULL) exit(0);

	if (Empty(st)) return false;

	*value = st->low[st->top - 1];
	return true;
}

bool Pop(Stack *st)
{
	if (st == NULL) exit(0);

	st->low[st->top--];
	return true;
}

static void ClearStack(Stack *st)//
{
	while (!Empty(st))//栈空执行
	{
		ElemType value;
		Top(st, &value);//获取栈顶元素
		printf("%c ", value);//输出栈顶元素
		Pop(st);//出栈
	}
	printf("\n");
}

static void DealRightPare(Stack *st)
{
	int flag = 0;
	while (!Empty(st))//栈非空
	{
		ElemType value;
		Top(st, &value);//获取栈顶元素
		Pop(st);//入栈

		if (value == '(')
		{
			flag = 1;
			break;
		}
		printf("%c ", value);
	}
	if (!flag)
	{
		printf("Pare is Error!");
	}
}

void DestroyStack(Stack *st)
{
	if (st == NULL) exit(0);

	free(st->low);
	st->low = NULL;//栈底指针为空防止成为野指针
	st->top = st->size = 0;
}


static void DealAddSub(Stack *st, char ch)
{
	while (!Empty(st))//栈空
	{
		ElemType value;
		Top(st, &value);
		if (value == '(') break;
		Pop(st);
		printf("%c ", value);
	}
	Push(st, ch); 
}

static void DealMultiDiv(Stack *st, char ch)
{
	while (!Empty(st))
	{
		ElemType value;
		Top(st, &value);
		if (value == '(' || value == '+'||value == '-') break;
		Pop(st);
		printf("%c ", value);
	}
	Push(st, ch);
}

void InfixToSuffix(char *infix)
{
	if (infix == NULL) exit(0);
	Stack st;
	InitStack(&st, INITSIZE);

	//遍历infix字符串
	int i = 0;
	while (infix[i] != '\0')
	{
		if (infix[i] == ' ')
		{
			i++;
			continue;
		}
		if (isdigit(infix[i]))
		{
			printf("%c", infix[i]);
			if (!isdigit(infix[i + 1]))
			{
				printf(" ");
			}
		}
		else if (infix[i] == '(')
		{
			Push(&st, infix[i]);
		}
		else if (infix[i] == ')')
		{
			DealAddSub(&st, infix[i]);
		}
		else if (infix[i] == '+' || infix[i] == '-')
		{
			DealAddSub(&st, infix[i]);
		}
		else if (infix[i] == '*' || infix[i] == '/')
		{
			DealMultiDiv(&st, infix[i]);
		}
		else
		{
			printf("Infix String is Error!\n");
			return;
		}
		i++;
	}
	ClearStack(&st);
	DestroyStack(&st);
}

int main()
{
	ElemType infix[] = "21*(9+6/3-5)+4";
	InfixToSuffix(infix);

	return 0;
}