中缀转后缀方法:
- 遇到数字:直接输出
- 遇到'(':压栈
- 遇到')':持续出栈,如果出栈的符号不是'('则输出,否则终止出栈。
- 遇到符号则判断该符号与栈顶符号的运算优先级,如果栈顶符号的运算优先级高,则出栈并输出,直到优先级相等或栈为空;如果栈顶符号的运算优先级低于或等于当前符号的运算优先级,则将当前符号压栈。
- 处理完字符串后将栈中剩余的符号全部输出
下面代码中的栈都是自己写的函数:
链式链表,链式存储的栈,还有中缀转后缀的头文件:
#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");
}