中缀转后缀

中缀转后缀方法：

1. 遇到数字：直接输出
   
2. 遇到'('：压栈  
3. 遇到')'：持续出栈，如果出栈的符号不是'('则输出，否则终止出栈。  
4. 遇到符号则判断该符号与栈顶符号的运算优先级，如果栈顶符号的运算优先级高，则出栈并输出，直到优先级相等或栈为空；如果栈顶符号的运算优先级低于或等于当前符号的运算优先级，则将当前符号压栈。  
5. 处理完字符串后将栈中剩余的符号全部输出

例如：2+（3-1）*5  ==》231-5*+

下面代码中的栈都是自己写的函数：

链式链表，链式存储的栈，还有中缀转后缀的头文件：

#ifndef __LINKSTACK_H__  //链式存储的栈
#define __LINKSTACK_H__

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"
#include "stdlib.h"
#include "nodelist.h"
#include "string.h"

typedef void LinkStack;
typedef void LinkStackNode;

LinkStack * LinkStack_Create();
void LinkStack_Destroy(LinkStack * stack);
void LinkStack_Clear(LinkStack * stack);
int LinkStack_Length(LinkStack * stacck);

int LinkStack_Push(LinkStack * stack, LinkStackNode * node);
LinkStack * LinkStack_Pop(LinkStack *stack);
LinkStack * LinkStack_Top(LinkStack * stack);



#endif

#ifndef __NODELIST_H__
#define __NODELIST_H__

#include "stdio.h"
#include "stdlib.h"

typedef void NodeList;
typedef struct _tag_NodeListNode  //单个节点
{
	struct _tag_NodeListNode * next;
}NodeListNode;

NodeList * NodeList_Create();//链表创建

void NodeList_Destroy(NodeList * list); //销毁链表

void NodeList_Clear(NodeList * list);//清空链表

int NodeList_Length(NodeList *list);//获取链表长度

int NodeList_insert(NodeList *list, NodeListNode *node, int pos);//插入节点

NodeList *NodeList_Get(NodeList *list, int pos);//获取链表中的元素

NodeList *NodeList_Delete(NodeList *list, int pos);//删除节点







#endif

#ifndef __TRANSFORM_H__
#define __TRANSFORM_H__

#include "LinkStack.h"
#include "nodelist.h"

void output(char ch);//输出
void transform(const char *ch);//中缀转后缀
int IsNumber(char ch);//判断是否是数字
int IsOperator(char ch);//判断是否是符号
int IsRight(char ch);//判断是否是右括号
int IsLeft(char ch);//判断是否是左括号
int priority(char ch);//判断优先级
int IsBracket(char ch);//判断是否是括号



#endif

 下面是以上函数的实现：

#include "LinkStack.h"

typedef struct TLinkStackNode
{
	NodeListNode   node;
	LinkStackNode * tnode;
}TLinkStackNode;


LinkStack * LinkStack_Create()
{
	return (LinkStack *)NodeList_Create();
}


void LinkStack_Destroy(LinkStack * stack)
{
	if (stack == NULL)
	{
		return;
	}

	LinkStack_Clear(stack);
	NodeList_Destroy((NodeList *)stack);
}
void LinkStack_Clear(LinkStack * stack)
{
	if (stack == NULL)
	{
		return;
	}
	while (LinkStack_Length(stack) > 0)
	{
		LinkStack_Pop(stack);
	}
	return;
}


int LinkStack_Length(LinkStack * stack)
{
	return NodeList_Length((NodeList *)stack);
}



int LinkStack_Push(LinkStack * stack, LinkStackNode * node)
{
	TLinkStackNode * tmp = NULL;
	int ret = 0;
	tmp = (TLinkStackNode *)malloc(sizeof(TLinkStackNode));
	if (tmp == NULL)
	{
		return -1;
	}
	memset(tmp, 0, sizeof(tmp));
	tmp->tnode = node;
	ret = NodeList_insert((NodeList *)stack, (NodeListNode *)tmp, 0);
	if (ret != 0)
	{
		free(tmp);
		return -2;
	}
	return 0;
}


LinkStack * LinkStack_Pop(LinkStack *stack)
{
	TLinkStackNode * tmp = NULL;
	tmp = (TLinkStackNode *)NodeList_Delete((NodeList *)stack, 0);
	if (tmp == NULL)
	{
		return NULL;
	}
	LinkStackNode *tnode = NULL;
	tnode = tmp->tnode;
	free(tmp);
	return (LinkStack *)tnode;
}
LinkStack * LinkStack_Top(LinkStack * stack)
{
	TLinkStackNode * tmp = NULL;
	tmp = (TLinkStackNode *)NodeList_Get((NodeList *)stack, 0);
	if (tmp == NULL)
	{
		return NULL;
	}
	LinkStackNode *tnode = NULL;
	tnode = tmp->tnode;
	return (LinkStack *)tnode;

}

#include "nodelist.h"  

typedef struct TNodeList
{
	NodeListNode header;   //和老师类一样，一定要放在第一位，偏移量的问题，  header的地址就是链表最前面那个头的地址
	int length;//链表的长度
	
}TNodeList;

NodeList * NodeList_Create()//链表创建
{
	TNodeList *list = NULL;
	list = (TNodeList *)malloc(sizeof(TNodeList));
	if (list == NULL)
	{
		printf("ERROR!! FUNC NodeList_Create()  申请内存失败\n");
		return NULL;
	}

	list->length = 0;
	list->header.next = NULL;//初始化

	return list;
}
void NodeList_Destroy(NodeList * list) //销毁链表
{
	TNodeList *tlist = NULL;
	tlist = (TNodeList *)list;
	if (tlist != NULL)
	{
		free(list);
	}
	return;
}

void NodeList_Clear(NodeList * list)//清空链表
{
	TNodeList *tlist = NULL;
	tlist = (TNodeList *)list;
	if (tlist == NULL)
	{
		return;
	}
	tlist->length = 0;
	tlist->header.next = NULL;
	
	return;
}

int NodeList_Length(NodeList *list)//获取链表长度
{
	TNodeList *tlist = NULL;
	tlist = (TNodeList *)list;
	if (tlist == NULL)
	{
		return -1;
	}
	return tlist->length;
}

int NodeList_insert(NodeList *list, NodeListNode *node, int pos)//插入节点
{
	int ret = 0;
	
	if (list == NULL || node == NULL || pos < 0)
	{
		ret = -3;
		return ret;
	}

	TNodeList *tlist = NULL;
	tlist = (TNodeList *)list;
	if (tlist == NULL)
	{
		ret = -1;
		return ret;
	}

	NodeListNode *current = NULL;
	current = (NodeListNode *)list;
	if (current == NULL)
	{
		ret = -2;
		return ret;
	}
	
	if (pos > NodeList_Length(list))
	{
		ret = -4;
		return ret;
	}

	for (int i = 0; i < pos ; i++)
	{
		current = current->next;
	}

	node->next = current->next;
	current->next = node;
	tlist->length++;
	
	return ret;
}

NodeList *NodeList_Get(NodeList *list, int pos)//获取链表中的元素
{
	if (list == NULL || pos < 0)
	{
		return NULL;
	}

	TNodeList *tlist = NULL;
	tlist = (TNodeList *)list;
	if (tlist == NULL)
	{
		return NULL;
	}
	
	if (pos >= NodeList_Length(list))
	{
		return NULL;
	}

	NodeListNode *current = NULL;
	current = (NodeListNode *)list;
	if (current == NULL)
	{
		return NULL;
	}

	for (int i = 0; i < pos; i++)
	{
		current = current->next;
	}

	return (NodeList *)(current->next);

}
NodeList *NodeList_Delete(NodeList *list, int pos)//删除节点
{
	if (list == NULL || pos < 0)
	{
		return NULL;
	}

	TNodeList *tlist = NULL;
	tlist = (TNodeList *)list;
	if (tlist == NULL)
	{
		return NULL;
	}

	if (pos >= NodeList_Length(list))
	{
		return NULL;
	}

	NodeListNode *current = NULL;
	current = (NodeListNode *)list;
	if (current == NULL)
	{
		return NULL;
	}

	for (int i = 0; i < pos; i++)
	{
		current = current->next;
	}

	NodeListNode *last = NULL;
	last = current->next;
	current->next = last->next;

	tlist->length--;

	return (NodeList *)last;

}

#include "transform.h"


void output(char ch)
{
	if (ch != '\0')
	{
		printf("%c", ch);
	}
}
void transform(const char *ch)
{
	int ret = 0;
	char *ext = NULL;
	int length = strlen(ch);
	ext = (char *)malloc(sizeof(char)*(length + 1));
	if (ext == NULL)
	{
		return;
	}
	strcpy(ext, ch);
	int i = 0;
	LinkStack * stack = NULL;
	stack = LinkStack_Create();
	while (ext[i] != '\0')
	{
		if (IsNumber(ext[i]))//如果是数字直接输出
		{
			output(ext[i]);
		}
		else
		if (IsOperator(ext[i]))//如果是符号
		{
			int a = priority(ext[i]);
			int b = priority((char)LinkStack_Top(stack));
			while (a <= b)//判断与栈顶元素的优先级，高于栈顶元素入栈，否则栈顶元素出栈输出，直到高于栈顶元素
			{
				output((char)LinkStack_Pop(stack));
				a = priority(ext[i]);
				b = priority((char)LinkStack_Top(stack));
			}
			ret = LinkStack_Push(stack, (LinkStackNode*)ext[i]);//高于栈顶元素后入栈
		}
		else if (IsBracket(ext[i]))//如果是括号
		{
			if (IsLeft(ext[i]))//左括号直接入栈
			{
				ret = LinkStack_Push(stack, (LinkStackNode*)ext[i]);
			}
			else if (IsRight(ext[i]))//右括号 一直出栈输出，直到匹配到左括号
			{
				while ((char)LinkStack_Top(stack) != '(')
				{
					output((char)LinkStack_Pop(stack));
				}
				LinkStack_Pop(stack);
			}
		}
		else
		{
			printf("invalid expression\n");
			break;
		}
		i++;
	}
	while (LinkStack_Length(stack) != 0)
	{
		output((char)LinkStack_Pop(stack));//当字符串扫描结束后，所有符号出栈输出
	}
	LinkStack_Destroy(stack);
        free(ext);
       return;
}
int IsNumber(char ch)
{
	if (ch >= '0'&&ch <= '9')
	{
		return 1;
	}
	return 0;
}
int IsOperator(char ch)
{
	if (ch == '+' || ch == '-' || ch == '*' || ch == '/' )
	{
		return 1;
	}
	return 0;
}
int IsBracket(char ch)
{
	if (ch == '(' || ch == ')')
	{
		return 1;
	}
	return 0;
}
int IsRight(char ch)
{
	if (ch == ')')
	{
		return 1;
	}
	return 0;
}
int IsLeft(char ch)
{
	if (ch == '(')
	{
		return 1;
	}
	return 0;
}
int priority(char ch)
{
	if (ch == '*' || ch == '/')
	{
		return 3;
	}
	if (ch == '+' || ch == '-')
	{
		return 2;
	}
	if (ch == '(')
	{
		return 1;
	}
	else
	{
		return 0;
	}
	
}

下面是测试程序：

#include "transform.h"
void main()
{
	char *p = "2+(3-1)*5";
	transform(p);
	printf("\n");
	system("pause");
}