【C】【Stack】链栈实现中缀转后缀

链栈实现中缀转后缀

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

typedef char DataType;

typedef struct data {
	DataType data;
}Item;

typedef struct node {
	Item item;
	struct node* next;
}Node;

typedef struct {
	Node* top;
	Node* bottom;
	int node_num;
}Stack;

bool InitStack(Stack* pstack);//初始化栈
bool StackIsEmpty(Stack* pstack);//判断栈是否为空
bool StackIsFull(Stack* pstack);//判断栈是否已满
bool PushStack(Stack* pstack, DataType data);//进栈
bool PopStack(Stack* pstack);//出栈
DataType GetTop(Stack* pstack);//获取栈顶元素
bool PrintStack(Stack* pstack);//打印全体栈元素
bool FreeStack(Stack* pstack);//释放栈
bool ComOper(Stack* pstack, char ch);//运算符比较
void FunLz(Stack* ptemp, Stack* poper);//中缀转后缀

bool InitStack(Stack* pstack)
{
	pstack->node_num = 0;
	pstack->top = (Node*)malloc(sizeof(Node));
	pstack->bottom = NULL;
	pstack->top->next = pstack->bottom;

	if (pstack->bottom != NULL)
		return false;
	if (pstack->top->next != pstack->bottom)
		return false;
		
	return true;
}

bool StackIsEmpty(Stack* pstack)
{
	bool empty = true;

	if (pstack->node_num == 0)
		return empty;
	else return !empty;
}

bool StackIsFull(Stack* pstack)
{
	bool full = true;
	Node* ptemp;
	ptemp = (Node*)malloc(sizeof(Node));

	if (ptemp == NULL)
	{
		free(ptemp);
		return full;
	}
	else
	{
		free(ptemp);
		return !full;
	}
}

bool PushStack(Stack* pstack, DataType data)
{
	Node* pnew;
	pnew = (Node*)malloc(sizeof(Node));
	if (pnew == NULL)
		return false;
	pnew->item.data = data;

	if (StackIsEmpty(pstack) == true)
	{
		pnew->next = pstack->bottom;//新节点指向栈底
		pstack->top = pnew;//新节点变成栈顶
		pstack->node_num++;//节点计数增加
		return true;
	}

	if (StackIsEmpty(pstack) == false)
	{
		pnew->next = pstack->top;//新节点指向栈顶
		pstack->top = pnew;//新节点变成“真”栈顶
		pstack->node_num++;//节点计数增加
		return true;
	}

	return false;
}

bool PopStack(Stack* pstack)
{
	Node* ptemp;
	
	if (StackIsEmpty(pstack) == true)
	{
		printf("栈空！无法出栈！\n");
		return false;
	}
	else
	{
		ptemp = pstack->top;//临时节点保存栈顶
		pstack->top = pstack->top->next;//栈顶向前推进
		free(ptemp);//释放原栈顶
		pstack->node_num--;//节点计数减少
		return true;
	}
}

DataType GetTop(Stack* pstack)
{
	if (StackIsEmpty(pstack) == true)
	{
		printf("栈空！无法获取栈顶元素！\n");
		return false;
	}
	else
		return pstack->top->item.data;
}

bool PrintStack(Stack* pstack)
{
	Node* pscan = pstack->top;//获取当前栈顶
	if (StackIsEmpty(pstack) == true)
	{
		printf("栈空！无法打印栈元素！\n");
		return false;
	}
	else
	{
		printf("全体栈元素：");
		while (pscan != NULL)
		{
			printf("%c", pscan->item.data);
			pscan = pscan->next;//向前
		}
		putchar('\n');
		return true;
	}
}

bool FreeStack(Stack* pstack)
{
	Node* ptemp = pstack->top;//获取当前栈顶

	if (StackIsEmpty(pstack) == true)
	{
		printf("栈空！无需释放！\n");
		return false;
	}
	else
	{
		//栈顶非空时
		while (ptemp != NULL)
		{
			pstack->top = pstack->top->next;//栈顶向前
			free(ptemp);//释放原栈顶
			ptemp = pstack->top;//保存当前栈顶
		}
		return true;
	}
}

bool ComOper(Stack* pstack, char ch)
{
	bool greater = true;
	bool equal = false;
	bool less = false;
	
	if (ch == '*' || ch == '/')
	{
		if (GetTop(pstack) == '*' || GetTop(pstack) == '/')
			return equal;
		else
			return greater;
	}
	else if (ch == '+' || ch == '-')
		return less;
	else
		return false;
}

void FunLz(Stack* ptemp, Stack* poper)
{
	char ch, temp;
	int n;
	do {
		//进行输入
		scanf_s("%c", &ch, (int)sizeof(char));
		if(ch != '#')
			printf("输入%c\n", ch);

		//'#'停止输入
		if (ch == '#')break;
		//为数字直接入临时结果栈
		else if (ch >= '0' && ch <= '9')
		{
			PushStack(ptemp, ch);
			printf("%c进临时结果栈\n", ch);
		}
		//为运算符时
		else
		{
			//如果 “运算符栈空” 或 “输入的为'('” 时，直接压入运算符栈
			if (StackIsEmpty(poper) == true || ch == '(')
			{
				PushStack(poper, ch);
				printf("%c进运算符栈\n", ch);
			}
			//输入')'时
			else if (ch == ')')
			{
				//到运算符栈顶元素为'('止
				while (GetTop(poper) != '(')
				{
					temp = GetTop(poper);
					PopStack(poper);
					printf("%c出运算符栈\n", temp);
					PushStack(ptemp, temp);
					printf("%c进临时结果栈\n", temp);
				}
				PopStack(poper);//把'('出运算符栈
				printf("(出运算符栈\n");
			}
			//括号输入已经处理完毕
			//运算符栈顶元素为'('
			else if (GetTop(poper) == '(')
			{
				PushStack(poper, ch);
				printf("%c进运算符栈\n", ch);
			}
			else
			{
				//如果优先级高
				if (ComOper(poper, ch) == true)
				{
					PushStack(poper, ch);
					printf("%c进运算符栈\n",ch);
				}
				//如果优先级低或相同
				else
				{
					temp = GetTop(poper);
					PopStack(poper);
					printf("%c出运算符栈\n", temp);
					PushStack(ptemp, temp);
					printf("%c进临时结果栈\n", temp);
					PushStack(poper, ch);
					printf("%c进运算符栈\n", ch);
				}
			}
		}

		if (StackIsEmpty(ptemp) == false)
		{
			printf("临时结果");
			PrintStack(ptemp);
		}
		if (StackIsEmpty(poper) == false)
		{
			printf("运算符");
			PrintStack(poper);
		}

		putchar('\n');
	} while(ch != '#');

	//处理剩余内容
	while (getchar() != '\n')
		continue;

	//将运算符栈剩余内容压入临时结果栈
	n = poper->node_num;
	//printf("n = %d\n", n);
	//system("pause");
	while (n--)
	{
		temp = GetTop(poper);
		PopStack(poper);
		printf("%c出运算符栈\n", temp);
		PushStack(ptemp, temp);
		printf("%c进临时结果栈\n", temp);

		if (StackIsEmpty(ptemp) == false)
		{
			printf("临时结果");
			PrintStack(ptemp);
		}
		if (StackIsEmpty(poper) == false)
		{
			printf("运算符");
			PrintStack(poper);
		}
	}
	putchar('\n');
}

int main()
{
	Stack S1;
	Stack S2;

	if (InitStack(&S1) && InitStack(&S2))
		printf("程序运行……\n");
	else
		exit(1);

	if (StackIsFull(&S1) == false && StackIsFull(&S2) == false)
		FunLz(&S1, &S2);
	else
		exit(1);

	if (StackIsEmpty(&S1) == false)
		PrintStack(&S1);

	if(StackIsEmpty(&S2) == false)
		PrintStack(&S2);
		
	FreeStack(&S1);
	
	return 0;
}