阅读背景：

中缀转后缀表达式代码

来源：互联网  
中缀表达式转后缀表达式
遇到数字原样输出，遇到操作符入栈，入栈时要判断栈内已有的操作符的优先级和需要判断的操作符的优先级的大小
代码：
#define OPERATORS_PRIO_PLUS_IN  4  //栈内加法
#define OPERATORS_PRIO_SUB_IN  4   //栈内减法
#define OPERATORS_PRIO_MULTY_IN  2 //栈内乘法
#define OPERATORS_PRIO_DIV_IN  2   //栈内除法
#define OPERATORS_PRIO_LEFT_BRAK_IN  10  //栈内左括号

#define OPERATORS_PRIO_PLUS_OUT  5  //栈外加法
#define OPERATORS_PRIO_SUB_OUT   5   //栈外减法
#define OPERATORS_PRIO_MULTY_OUT  3 //栈外乘法
#define OPERATORS_PRIO_DIV_OUT  3   //栈外除法
#define OPERATORS_PRIO_LEFT_BRAK_OUT 1  //栈外左括号
#define OPERATORS_PRIO_RIGHT_BRAK_OUT 10  //栈外右括号
#define OPERATORS_PRIO_ERROR -1


#include<stdio.h>
#include<ctype.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
int Get_Prio(char opera, bool instack)
{
	int prio = OPERATORS_PRIO_ERROR;
	if (instack)
	{
		switch (opera)
		{
		case '+':
			prio = OPERATORS_PRIO_PLUS_IN;
			break;
		case '-':
			prio = OPERATORS_PRIO_SUB_IN;
			break;
		case '*':
			prio = OPERATORS_PRIO_MULTY_IN;
			break;
		case '/':
			prio = OPERATORS_PRIO_DIV_IN;
			break;
		case '(':
			prio = OPERATORS_PRIO_LEFT_BRAK_IN;
			break;
		default:
			prio = OPERATORS_PRIO_ERROR;
			break;
		}
	}
	else
	{
		switch (opera)
		{
		case '+':
			prio = OPERATORS_PRIO_PLUS_OUT;
			break;
		case '-':
			prio = OPERATORS_PRIO_SUB_OUT;
			break;
		case '*':
			prio = OPERATORS_PRIO_MULTY_OUT;
			break;
		case '/':
			prio = OPERATORS_PRIO_DIV_OUT;
			break;
		case '(':
			prio = OPERATORS_PRIO_LEFT_BRAK_OUT;
			break;
		case ')':
			prio = OPERATORS_PRIO_RIGHT_BRAK_OUT;
			break;
		default:
			prio = OPERATORS_PRIO_ERROR;
			break;
		}
	}
	return prio;
}
  bool MiddleToLast(char *strLast, const char *strMid)
{
	assert(*strMid != NULL&&*strLast != NULL);
	char*stack = (char*)malloc(sizeof(char)*strlen(strMid));
	assert(stack != NULL);
	int top = 0;
	while (*strMid != '
 
 
中缀表达式转后缀表达式
遇到数字原样输出，遇到操作符入栈，入栈时要判断栈内已有的操作符的优先级和需要判断的操作符的优先级的大小
代码：
#define OPERATORS_PRIO_PLUS_IN  4  //栈内加法
#define OPERATORS_PRIO_SUB_IN  4   //栈内减法
#define OPERATORS_PRIO_MULTY_IN  2 //栈内乘法
#define OPERATORS_PRIO_DIV_IN  2   //栈内除法
#define OPERATORS_PRIO_LEFT_BRAK_IN  10  //栈内左括号

#define OPERATORS_PRIO_PLUS_OUT  5  //栈外加法
#define OPERATORS_PRIO_SUB_OUT   5   //栈外减法
#define OPERATORS_PRIO_MULTY_OUT  3 //栈外乘法
#define OPERATORS_PRIO_DIV_OUT  3   //栈外除法
#define OPERATORS_PRIO_LEFT_BRAK_OUT 1  //栈外左括号
#define OPERATORS_PRIO_RIGHT_BRAK_OUT 10  //栈外右括号
#define OPERATORS_PRIO_ERROR -1


#include<stdio.h>
#include<ctype.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
int Get_Prio(char opera, bool instack)
{
	int prio = OPERATORS_PRIO_ERROR;
	if (instack)
	{
		switch (opera)
		{
		case '+':
			prio = OPERATORS_PRIO_PLUS_IN;
			break;
		case '-':
			prio = OPERATORS_PRIO_SUB_IN;
			break;
		case '*':
			prio = OPERATORS_PRIO_MULTY_IN;
			break;
		case '/':
			prio = OPERATORS_PRIO_DIV_IN;
			break;
		case '(':
			prio = OPERATORS_PRIO_LEFT_BRAK_IN;
			break;
		default:
			prio = OPERATORS_PRIO_ERROR;
			break;
		}
	}
	else
	{
		switch (opera)
		{
		case '+':
			prio = OPERATORS_PRIO_PLUS_OUT;
			break;
		case '-':
			prio = OPERATORS_PRIO_SUB_OUT;
			break;
		case '*':
			prio = OPERATORS_PRIO_MULTY_OUT;
			break;
		case '/':
			prio = OPERATORS_PRIO_DIV_OUT;
			break;
		case '(':
			prio = OPERATORS_PRIO_LEFT_BRAK_OUT;
			break;
		case ')':
			prio = OPERATORS_PRIO_RIGHT_BRAK_OUT;
			break;
		default:
			prio = OPERATORS_PRIO_ERROR;
			break;
		}
	}
	return prio;
}
  bool MiddleToLast(char *strLast, const char *strMid)
{
	assert(*strMid != NULL&&*strLast != NULL);
	char*stack = (char*)malloc(sizeof(char)*strlen(strMid));
	assert(stack != NULL);
	int top = 0;
	while (*strMid != '\0')
	{
		if (isdigit(*strMid))
		{
			*strLast++ = *strMid++;
		}
		else
		{
			if (top==0)
			{
				stack[top++] =*strMid++;
			}
			else
			{
				if (Get_Prio(stack[top - 1], true) > Get_Prio(*strMid, false))  //栈外优先级高
				{
					stack[top++] == *strMid++;
				}
				else if (Get_Prio(stack[top - 1], true) == Get_Prio(*strMid, false))  //内外优先级一样
				{
					top--;
					*strMid++;
				}
				else if (Get_Prio(stack[top - 1], true) < Get_Prio(*strMid, false))  //栈内优先级高
				{
					*strLast++ = stack[--top];
				}
			}
		}
	}
	while (top!=0)
	{
		*strLast++ = stack[--top];
	}
	*strLast = '\0';
	free(stack);
	stack = NULL;
	return true;
}

void main()
{
	char *strMid = "5+1";
	char strLast[10];
	MiddleToLast(strLast, strMid);
	printf("%s\n", strLast);
}
 
 
 
 
 
  
  


')
	{
		if (isdigit(*strMid))
		{
			*strLast++ = *strMid++;
		}
		else
		{
			if (top==0)
			{
				stack[top++] =*strMid++;
			}
			else
			{
				if (Get_Prio(stack[top - 1], true) > Get_Prio(*strMid, false))  //栈外优先级高
				{
					stack[top++] == *strMid++;
				}
				else if (Get_Prio(stack[top - 1], true) == Get_Prio(*strMid, false))  //内外优先级一样
				{
					top--;
					*strMid++;
				}
				else if (Get_Prio(stack[top - 1], true) < Get_Prio(*strMid, false))  //栈内优先级高
				{
					*strLast++ = stack[--top];
				}
			}
		}
	}
	while (top!=0)
	{
		*strLast++ = stack[--top];
	}
	*strLast = '
 
 
中缀表达式转后缀表达式
遇到数字原样输出，遇到操作符入栈，入栈时要判断栈内已有的操作符的优先级和需要判断的操作符的优先级的大小
代码：
#define OPERATORS_PRIO_PLUS_IN  4  //栈内加法
#define OPERATORS_PRIO_SUB_IN  4   //栈内减法
#define OPERATORS_PRIO_MULTY_IN  2 //栈内乘法
#define OPERATORS_PRIO_DIV_IN  2   //栈内除法
#define OPERATORS_PRIO_LEFT_BRAK_IN  10  //栈内左括号

#define OPERATORS_PRIO_PLUS_OUT  5  //栈外加法
#define OPERATORS_PRIO_SUB_OUT   5   //栈外减法
#define OPERATORS_PRIO_MULTY_OUT  3 //栈外乘法
#define OPERATORS_PRIO_DIV_OUT  3   //栈外除法
#define OPERATORS_PRIO_LEFT_BRAK_OUT 1  //栈外左括号
#define OPERATORS_PRIO_RIGHT_BRAK_OUT 10  //栈外右括号
#define OPERATORS_PRIO_ERROR -1


#include<stdio.h>
#include<ctype.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
int Get_Prio(char opera, bool instack)
{
	int prio = OPERATORS_PRIO_ERROR;
	if (instack)
	{
		switch (opera)
		{
		case '+':
			prio = OPERATORS_PRIO_PLUS_IN;
			break;
		case '-':
			prio = OPERATORS_PRIO_SUB_IN;
			break;
		case '*':
			prio = OPERATORS_PRIO_MULTY_IN;
			break;
		case '/':
			prio = OPERATORS_PRIO_DIV_IN;
			break;
		case '(':
			prio = OPERATORS_PRIO_LEFT_BRAK_IN;
			break;
		default:
			prio = OPERATORS_PRIO_ERROR;
			break;
		}
	}
	else
	{
		switch (opera)
		{
		case '+':
			prio = OPERATORS_PRIO_PLUS_OUT;
			break;
		case '-':
			prio = OPERATORS_PRIO_SUB_OUT;
			break;
		case '*':
			prio = OPERATORS_PRIO_MULTY_OUT;
			break;
		case '/':
			prio = OPERATORS_PRIO_DIV_OUT;
			break;
		case '(':
			prio = OPERATORS_PRIO_LEFT_BRAK_OUT;
			break;
		case ')':
			prio = OPERATORS_PRIO_RIGHT_BRAK_OUT;
			break;
		default:
			prio = OPERATORS_PRIO_ERROR;
			break;
		}
	}
	return prio;
}
  bool MiddleToLast(char *strLast, const char *strMid)
{
	assert(*strMid != NULL&&*strLast != NULL);
	char*stack = (char*)malloc(sizeof(char)*strlen(strMid));
	assert(stack != NULL);
	int top = 0;
	while (*strMid != '\0')
	{
		if (isdigit(*strMid))
		{
			*strLast++ = *strMid++;
		}
		else
		{
			if (top==0)
			{
				stack[top++] =*strMid++;
			}
			else
			{
				if (Get_Prio(stack[top - 1], true) > Get_Prio(*strMid, false))  //栈外优先级高
				{
					stack[top++] == *strMid++;
				}
				else if (Get_Prio(stack[top - 1], true) == Get_Prio(*strMid, false))  //内外优先级一样
				{
					top--;
					*strMid++;
				}
				else if (Get_Prio(stack[top - 1], true) < Get_Prio(*strMid, false))  //栈内优先级高
				{
					*strLast++ = stack[--top];
				}
			}
		}
	}
	while (top!=0)
	{
		*strLast++ = stack[--top];
	}
	*strLast = '\0';
	free(stack);
	stack = NULL;
	return true;
}

void main()
{
	char *strMid = "5+1";
	char strLast[10];
	MiddleToLast(strLast, strMid);
	printf("%s\n", strLast);
}
 
 
 
 
 
  
  


';
	free(stack);
	stack = NULL;
	return true;
}

void main()
{
	char *strMid = "5+1";
	char strLast[10];
	MiddleToLast(strLast, strMid);
	printf("%s\n", strLast);
}中缀表达式转后缀表达式
遇到数字原样输出，遇到操作符入栈，入栈时要判断栈内已有的操作符的优先级


你的当前访问异常,请进行认证后继续阅读剩余内容。

分享到：
你可能喜欢:
相关阅读:
随便看看: