精华内容
下载资源
问答
  •  最后得到的结果就是 一个反向的 后缀表达式 */ #include #include #include typedef double DateType; typedef char SymbolType; typedef struct RpnNode{ SymbolType symol; DateType data; ...

    /*

    • 首先声明两类型的栈每个类型两个栈, 其中一个栈存储数值(dptr) 一个用来存临时的运算符的(sptr)
    • 当遇到数值的时候 入栈(dptr)
    • 当遇到 + - * \ ( 的运算符的时候入栈(sptr)
    • 当遇到 ) 的时候 sptr出栈,出栈的结果 入栈(dptr) 直到 出栈得出的结果是(  ’(‘ )
    • 每次数值入栈后 判断运算符的栈顶符号 如果是 * / 则 出栈出栈结果到(dptr)

      最后得到的结果就是 一个反向的 后缀表达式

    */

    #include <stdio.h>
    #include <stdlib.h>
    #include <ctype.h>
    
    typedef double DateType;
    typedef char SymbolType;
    
    typedef struct RpnNode{
      SymbolType symol;
      DateType data;
    
      struct RpnNode *next;
    }RpnNode, *RpnNodeList;
    
    typedef struct RpnNodeSave{
      RpnNodeList top;
      RpnNodeList base;
      int count;
    }RpnNodeSave;
    
    // 数据进站
    void Push(RpnNodeSave *L, DateType data){
      RpnNode *node, *top;
    
      top = L->top;
      node = (RpnNode *)malloc(sizeof(RpnNode));
      node->data = data;
      node->next = top;
    
      L->top = node;
      L->count++;
    }
    
    // 运算符进站
    void symbolPush(RpnNodeSave *L, SymbolType symol){
      RpnNode *node, *top;
      top = L->top;
    
      node = (RpnNode *)malloc(sizeof(RpnNode));
      node->symol = symol;
      node->next = top;
    
      L->top = node;
      L->count++;
    }
    
    // 数值出站
    void Pop(RpnNodeSave *ptr, DateType *e){
      RpnNode *node, *topnext;
    
      node = ptr->top;
      *e = node->data;
      topnext = node->next;
    
      free(node);
    
      ptr->top = topnext;
      ptr->count--;
    }
    
    // 运算符出站
    void symbolPop(RpnNodeSave *ptr, SymbolType *e){
      RpnNode *node, *topnext;
    
      node = ptr->top;
      *e = node->symol;
      topnext = node->next;
    
      free(node);
    
      ptr->top = topnext;
      ptr->count--;
    }
    
    // 打印值
    void printStack(RpnNode *L){
      while(L->next){
        printf("(%f:%c)->", L->data, L->symol);
        L = L->next;
      }
    
      printf("\n");
    }
    
    char saveData(RpnNodeSave *dptr, char *data){
      int i = 0;
      char str[10];
      DateType store;
    
      while(isdigit(*data) || '.' == *data){
        str[i++] = *data;
        str[i] = '\0';
        if (i >= 10){
          printf("输入的单个数据过大\n");
          return '#';
        }
        scanf("%c", data);
        if(!isdigit(*data) && '.' != *data){
          store = atof(str);
          Push(dptr, store);
          i = 0;
          return *data;
        }
      }
    }
    
    int main(int argc, char const *argv[])
    {
      char data, tmp;
      int err = 0, i = 0;
    
      DateType start, end, result, store;
    
      // 数值的栈值
      RpnNode *dHead, *tmpStruct, *tmpNode, *tmpNext;
      dHead = (RpnNodeList)malloc(sizeof(RpnNode));
      dHead->next = NULL;
    
      // 数值统计的栈值
      RpnNodeSave *dptr;
      dptr = (RpnNodeSave *)malloc(sizeof(RpnNodeSave));
      dptr->top = dHead;
      dptr->base = dHead;
      dptr->count = 0;
    
      // 符号的栈值
      RpnNode *sHead, *tmpTop;
      sHead = (RpnNodeList)malloc(sizeof(RpnNode));
      sHead->next = NULL;
    
      // 符号统计的栈值
      RpnNodeSave *sptr;
      sptr = (RpnNodeSave *)malloc(sizeof(RpnNodeSave));
      sptr->top = sHead;
      sptr->base = sHead;
      sptr->count = 0;
    
      printf("请输入一串后缀表达式, 以Enter结束: \n");
      scanf("%c", &data);
    
      while(data != '\n'){
        saveData(dptr, &data);
    
        tmpTop = sptr->top;
        tmp = tmpTop->symol;
        if(tmp == '*' || tmp == '/'){
          symbolPop(sptr, &tmp);
          symbolPush(dptr, tmp);
        }
    
        if(data == '+' || data == '-' ||
           data == '*' ||
           data == '/' ||
           data == '('){
          symbolPush(sptr, data);
        }
    
        if(data == ')'){
          while(1){
            symbolPop(sptr, &tmp);
            if(tmp == '('){
              break;
            }
            symbolPush(dptr, tmp);
          }
        }
        scanf("%c", &data);
      }
    
      tmpStruct = sptr->top;
      while(tmpStruct->next){
        symbolPush(dptr, tmpStruct->symol); // 栈 1
        tmpStruct = tmpStruct->next;
      }
      printStack(dptr->top);
    
      // 开始按照逆波兰计算结果
      RpnNode *caclHead;
      caclHead = (RpnNodeList)malloc(sizeof(RpnNode));
      caclHead->next = NULL;
    
      tmpStruct = (RpnNodeList)malloc(sizeof(RpnNode));
      tmpStruct->next = NULL;
    
      // 数值统计的栈值
      RpnNodeSave *cptr;
      cptr = (RpnNodeSave *)malloc(sizeof(RpnNodeSave));
      cptr->top = caclHead;
      cptr->base = caclHead;
      cptr->count = 0;
    
      tmpNode = dptr->top;
      while(tmpNode->next){
        tmpNext = tmpNode->next;
    
        tmpNode->next = tmpStruct;
        tmpStruct = tmpNode;
        tmpNode = tmpNext;
      }
    
      while(tmpStruct->next){
        data = tmpStruct->symol;
    
        switch(data){
          case '+':
            Pop(cptr, &end);
            Pop(cptr, &start);
    
            Push(cptr, start + end);
            break;
          case '-':
            Pop(cptr, &end);
            Pop(cptr, &start);
    
            Push(cptr, start - end);
            break;
          case '*':
            Pop(cptr, &end);
            Pop(cptr, &start);
    
            Push(cptr, start * end);
            break;
          case '/':
            Pop(cptr, &end);
            Pop(cptr, &start);
    
            if(end == 0){
              printf("输入错误,除数不能为0\n");
              return -1;
            }
            Push(cptr, start / end);
            break;
          default:
            Push(cptr, tmpStruct->data);
        }
        tmpStruct = tmpStruct->next;
      }
    
    
      Pop(cptr, &result);
      printf("result: %f \n", result);
    
      getchar();
    
      return 0;
    }
    请输入一串后缀表达式, 以Enter结束: 
    1+(2-3)*4+10/5+10 
    (0.000000:+)->(0.000000:+)->(0.000000:+)->(10.000000:)->(0.000000:/)->(5.000000:)->(10.000000:)->(0.000000:*)->(4.000000:)->(0.000000:-)->(3.000000:)->(2.000000:)->(1.000000:)->
    result: 9.000000 
    

     

    展开全文
  • #include #include int precedence(char c) {  if(c=='*'||c=='/')  return 2;  if(c=='+'||c=='-')  return 1;  return 0; } int main() {  cha

    #include<stdio.h>

    #include<stdlib.h>

    int precedence(char c)

    {

        if(c=='*'||c=='/')

            return 2;

        if(c=='+'||c=='-')

            return 1;

        return 0;

    }

    int main()

    {

        char stack1[1000]; int top_index1=-1;

        char stack2[1000]; int top_index2=-1;

        char c;

        while(1)

        {

            scanf("%c",&c);

            if(c=='\n')

                break;

            else if(c>='0'&&c<='9')

            {

                top_index2++;

                stack2[top_index2]=c;

            }

            else if(c=='(')

            {

                top_index1++;

                stack1[top_index1]=c;

            }

            else if(c==')')

            {

                while(stack1[top_index1]!='(')

                {

                    top_index2++;

                    stack2[top_index2]=stack1[top_index1];

                    top_index1--;

                }

                top_index1--;

            }

            else if(c=='+'||c=='-'||c=='*'||c=='/')

            {

                if(top_index1==-1||precedence(c)>precedence(stack1[top_index1]))

                {

                    top_index1++;

                    stack1[top_index1]=c;

                }

                else

                {

                    while(top_index1>=0&&precedence(stack1[top_index1])>=precedence(c))

                    {

                        top_index2++;

                        stack2[top_index2]=stack1[top_index1];

                        top_index1--;

                    }

                    top_index1++;

                    stack1[top_index1]=c;

                }

            }

        }

        while(top_index1!=-1)

        {

            top_index2++;

            stack2[top_index2]=stack1[top_index1];

            top_index1--;

        }

        

       // printf("%s\n",stack2); printf("%d\n",top_index2);

        int stack3[1000]; int top_index3=-1;

        for(int i=0;i<=top_index2;i++)

        {

            if(stack2[i]>='0'&&stack2[i]<='9')

            {

                top_index3++;

                stack3[top_index3]=stack2[i]-48;

                continue;

            }

            else

            {

                if(stack2[i]=='+')

                {

                    int t1=stack3[top_index3];

                    int t2=stack3[top_index3-1];

                    top_index3--;

                    stack3[top_index3]=t1+t2;

                }

                if(stack2[i]=='-')

                {

                    int t1=stack3[top_index3];

                    int t2=stack3[top_index3-1];

                    top_index3--;

                    stack3[top_index3]=t2-t1;

                }

                if(stack2[i]=='*')

                {

                    int t1=stack3[top_index3];

                    int t2=stack3[top_index3-1];

                    top_index3--;

                    stack3[top_index3]=t1*t2;

                }

                if(stack2[i]=='/')

                {

                    int t1=stack3[top_index3];

                    int t2=stack3[top_index3-1];

                    top_index3--;

                    stack3[top_index3]=t2/t1;

                }

            }

        }

        printf("%d",stack3[0]);

    }



    展开全文
  • c语言实现中缀表达式转后缀表达式并求得计算结果,用顺序栈结构。 当输入者输入错误信息的时候需要报错,并说明错误的种类。
  • 三、中缀表达式转后缀表达式 例如: 中缀表达式:123+5*21-7/(4-3) 后缀表达式:123 5 21 * + 7 4 3 / - 转换规则: 如果是数字,直接输出; 如果是左括号,直接入栈; 如果是右括号,一直出栈,直到遇到第一个左...

    七、中缀表达式转后缀表达式

    例如:

    中缀表达式:123+5*21-7/(4-3)
    后缀表达式:123 5 21 * + 7 4 3 / -

    转换规则:

    如果是数字,直接输出;
    如果是左括号,直接入栈;
    如果是右括号,一直出栈,直到遇到第一个左括号;
    如果是*或者/,一直出栈,直到栈空或者左括号或者遇到+ -,当前符号入栈;
    如果是+或者-,一直出栈,直到栈空或者遇到左括号,当前符号入栈;

    如果中缀表达式走完,弹出占中所有的元素

    1、声明

    #pragma once
    
    //结构声明
    typedef char ElemType;
    
    
    //顺序栈实现
    typedef struct Stack
    {
    	ElemType *stack_low;  //存储数据	
    	int top;		//栈顶
    	int size;       //栈大小
    
    }Stack;
    
    
    //方法声明
    
    //初始化
    void InitStack(Stack* st, int init_size);
    
    //判满
    bool IsFull(Stack* st);
    
    //判空
    bool IsEmpty(Stack* st);
    
    //开辟新空间,转移数据
    static bool AppendNewSpace(Stack* st);
    
    //入栈
    bool Push(Stack* st, ElemType value);
    
    //出栈
    bool Pop(Stack* st);
    
    //求栈顶元素
    bool TopStack(Stack* st, ElemType* reval);
    
    //销毁栈
    void DestoryStack(Stack *st);
    
    //打印栈中元素
    void ShowStack(Stack* st);
    
    //中缀转后缀
    void InfixToSuffix(ElemType* ch, Stack* st);
    

    2、方法实现

    #include<stdio.h>
    #include<stdlib.h>
    #include"Middle_Rear.h"
    #include<malloc.h>
    #include<ctype.h>
    
    //初始化
    void InitStack(Stack* st, int init_size)
    {
    	if (st == NULL) exit(0);
    	
    	init_size = init_size > 0 ? init_size : 10;
    
    	st->stack_low = (ElemType*)malloc(sizeof(ElemType) * init_size);
    	if (st->stack_low == NULL) exit(0);
    
    	st->size = init_size;
    	st->top = 0;
    
    }
    
    //判满
    bool IsFull(Stack *st)
    {
    	if (st == NULL) return false;
    
    	return st->top == st->size;
    }
    
    //判空
    bool IsEmpty(Stack* st)
    {
    	if (st == NULL) return false;
    
    	return st->top == 0;
    
    }
    
    //开辟新空间,转移数据
    static bool AppendNewSpace(Stack* st)
    {
    	ElemType* new_space = (ElemType*)malloc(sizeof(ElemType) * st->size * 2);
    	if (new_space == NULL) return false;
    
    	for (int i = 0; i < st->size; i++)
    	{
    		new_space[i] = st->stack_low[i];
    	}
    
    	free(st->stack_low);
    	st->stack_low = new_space;
    	st->size *= 2;
    	
    	return true;
    
    }
    
    
    //入栈
    bool Push(Stack* st, ElemType value)
    {
    	if (st == NULL) return false;
    
    	//考虑是否栈满
    	if (IsFull(st)) 
    	{
    		AppendNewSpace(st);
    	}
    
    	st->stack_low[st->top] = value;
    	st->top++;
    
    	return true;
    }
    
    //出栈
    bool Pop(Stack* st)
    {
    	if (st == NULL) return false;
    
    	if (IsEmpty(st)) return false;
    
    	st->top--;
    	
    	return true;
    }
    
    //求栈顶元素
    bool TopStack(Stack *st,ElemType *reval)
    {
    	if (st == NULL) exit(0);
    
    	//如果栈空
    	if (IsEmpty(st)) return false;
    
    	*reval = st->stack_low[st->top - 1];
    
    	return true;
    }
    
    //销毁栈
    void DestoryStack(Stack* st)
    {
    	if (st == NULL) exit(0);
    
    	while (!IsEmpty(st))
    	{
    		Pop(st);
    	}
    
    	free(st->stack_low);
    	st->stack_low = NULL;
    	st->size = st->top = 0;
    }
    
    //打印栈中元素
    void ShowStack(Stack* st)
    { 
    	if (st == NULL) exit(0);
    
    	while (!IsEmpty(st))
    	{
    		printf("%c ", st->stack_low[st->top-1]);
    		Pop(st);
    	}
    }
    
    //中缀转后缀
    void InfixToSuffix(ElemType* ch,Stack *st)
    {
    	char top_elem;//存储栈顶元素
    
    	for (int i = 0; ch[i] != '\0'; i++)
    	{
    		//如果是数字就直接输出
    		if (isdigit(ch[i]))
    		{
    			if (isdigit(ch[i + 1]))
    			{
    				printf("%c", ch[i]);
    			}
    			else
    			{
    				printf("%c ", ch[i]);
    			}
    
    			continue;
    		}
    
    		//如果是'(',就执行入栈操作
    		if (ch[i] == '(')
    		{
    			Push(st, ch[i]);
    			continue;
    		}
    
    
    		//如果是')',就执行出栈操作,直到遇到第一个'('
    		if (ch[i] == ')')
    		{
    			while (1)
    			{
    				TopStack(st, &top_elem);
    				if (top_elem == '(')
    				{
    					Pop(st);
    					break;
    				}
    				Pop(st);
    			}
    
    			continue;
    		}
    
    		//如果是'*'或者'/',就是执行出栈操作,直到栈空或者栈顶元素是'+'或者'-'时,当前符号入栈
    		if (ch[i] == '*' || ch[i] == '/')
    		{
    			while (1)
    			{
    				TopStack(st, &top_elem);
    				if (top_elem == '+' || top_elem == '-' || IsEmpty(st))
    				{
    					Push(st, ch[i]);
    					break;
    				}
    				else
    				{
    					printf("%c ", top_elem);
    					Pop(st);
    				}
    			}
    
    			continue;
    		}
    
    		//如果是'+'或者'-',就执行出栈,直到栈空或者遇到'(',当前符号入栈
    		if (ch[i] == '+' || ch[i] == '-')
    		{
    
    			while (1)
    			{
    				TopStack(st, &top_elem);
    				if (top_elem == '(' || IsEmpty(st))
    				{
    					Push(st, ch[i]);
    					break;
    				}
    				else
    				{
    					printf("%c ", top_elem);
    					Pop(st);
    				}
    			}
    
    			continue;
    		}
    	}
    
    }
    

    3、主函数测试

    #include<stdio.h>
    #include"Middle_Rear.h"
    
    int main()
    {
    	char str[] = "123+5*21-7/(4-3)";
    
    	Stack space;//定义一个栈
    	
    
    	InitStack(&space,10);//初始化栈
    
    	//中缀转后缀
    	InfixToSuffix(str,&space);
    
    	//中缀表达式走完,打印栈中余下元素
    	ShowStack(&space);
    
    	//最后销毁栈
    	DestoryStack(&space);
    
    
    	return 0;
    }
    
    

    4、测试结果
    在这里插入图片描述

    5、结束语

    Doing things change things , no doing things , these things are exactly as they where.
    行动才能改变,没有行动,一切也会原封不动。在这里插入图片描述

    展开全文
  • 请设计程序将中缀表达式转换为后缀表达式。 输入格式: 输入在一行中给出不含空格的中缀表达式,可包含+、-、*、\以及左右括号(),表达式不超过20个字符。 输出格式: 在一行中输出转换后的后缀表达式,要求不同...

    算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。日常使用的算术表达式是采用中缀表示法,即二元运算符位于两个运算数中间。请设计程序将中缀表达式转换为后缀表达式。

    输入格式:

    输入在一行中给出不含空格的中缀表达式,可包含+-*\以及左右括号(),表达式不超过20个字符。

    输出格式:

    在一行中输出转换后的后缀表达式,要求不同对象(运算数、运算符号)之间以空格分隔,但结尾不得有多余空格。

    输入样例:

    2+3*(7-4)+8/4
    

    输出样例:

    2 3 7 4 - * + 8 4 / +

    解题思路:

    这道题比较混蛋,很混蛋,他也咩有告诉你到底是什么数字,而且还把“/”给打反了打成了“\”,其次呢,对于数字的输入不只是一位整数,而是:正负都有的多位小数输入 。骗子,曰噢。

    我的处理办法是用string::iterator来记录当前扫描到的位置,然后用这个iterator来进行数字的单独识别,其他情况按照逆波兰算法处理就好,其他博主的文章写的已经很多了,原理就不再赘述了,此处留下博主的一种实现方案。

    代码:

    #include <iostream>
    #include <map>
    #include <stack>
    #include <vector>
    
    using namespace std;
    
    typedef map<char, int> TokenLevel;
    
    vector<string> reversePolishNotation(const string& expression, const TokenLevel& tokenLevel);
    string readNumber(string::const_iterator& it, const string& expression);
    int main() {
    	const TokenLevel tokenLevel{
    		{'+', 1},{'-', 1},
    		{'*', 2},{'/', 2},
    		{'(', 0},{')', 0}
    	};
    
    	string inputExpression;
    	cin >> inputExpression;
    
    	auto res = reversePolishNotation(inputExpression, tokenLevel);
    	cout << res[0];
    	for (int i = 1; i < res.size(); i++) {
    		cout << " " << res[i];
    	}
    
    	return 0;
    }
    
    inline bool checkNumber(string::const_iterator& it, const string& expression) {
    	return isdigit(*it) ||
    		(it == expression.begin() || *(it - 1) == '(') && (*it == '-' || *it == '+') ||
    		*it == '.' && isdigit(*(it + 1));
    }
    string readNumber(string::const_iterator& it, const string& expression) {
    	string rtn;
    	while (it != expression.end() && checkNumber(it, expression))
    		if (*it != '+') rtn += *it++; else ++it;
    	return rtn;
    }
    
    vector<string> reversePolishNotation(const string& expression, const TokenLevel& tokenLevel) {
    	vector<string> result;
    	vector<char> buffer;
    	for (auto it = expression.begin(); it != expression.end();) {
    		auto ch = *it;
    		if (!checkNumber(it, expression)) {
    			if (ch == '(' || buffer.empty()) {
    				buffer.push_back(ch);
    			} else if (ch == ')') {
    				while (buffer.back() != '(') {
    					result.push_back(string{ buffer.back() });
    					buffer.pop_back();
    				}
    				buffer.pop_back();
    			} else {
    				if (tokenLevel.at(ch) <= tokenLevel.at(buffer.back())) {
    					while (!buffer.empty() && tokenLevel.at(ch) <= tokenLevel.at(buffer.back())) {
    						result.push_back(string{ buffer.back() });
    						buffer.pop_back();
    					}
    				}
    				buffer.push_back(ch);
    			}++it;
    		} else result.push_back(readNumber(it, expression));
    	}
    
    	while (!buffer.empty()) {
    		result.push_back(string{ buffer.back() });
    		buffer.pop_back();
    	}
    	return result;
    }
    

    当然,博主为什么这么写呢,当然是为了可读性可维护性还有可扩展性啦。

    举个🌰

    inline bool checkNumber(string::const_iterator& it, const string& expression);

    中的isdigit数字判定改为isalnum之后,就可以解析单词啦o(* ̄▽ ̄*)ブ

    inline bool checkNumber(string::const_iterator& it, const string& expression) {
    	return isalnum(*it) ||
    		(it == expression.begin() || *(it - 1) == '(') && (*it == '-' || *it == '+') ||
    		*it == '.' && isalnum(*(it + 1));
    }

    测试

    结尾:

    (´▽`ʃ♡ƪ) over~

    就这。

    展开全文
  • 大一菜鸟,初学编程,这是我的第一篇博客,希望能用博客记录我的成长之路。 初学数据结构,刚接触链表和栈,看到有中缀.../* 堆栈练习——中缀表达式转后缀表达式 */ #include #include #include #include<stdbool.h
  • 中缀转后缀
  • C语言中,将中缀表达式转后缀表达式,并计算它的结果,具体的思路如下: 1、定义两个栈,numStack用于存放运算对象,最后存放运算结果的,fuStack用于存放运算符号的 2、从左到右遍历字符串 3、如果当前的字符是...
  • 文章目录定义后缀表达式 定义 中缀表达式就是我们日常常见到的表达式如图 它是由操作数,运算符,界限符组成的。 大家都知道中缀表达式的运算顺序先算乘除再算加减,从左到右,如果由括号则先算括号里面的,当我们...
  • 请输入中缀表达式,以#作为结束标志: " ); scanf( " %c " ,& c); while ( c != ' # ' ){ while ( c>= ' 0 ' && c ' 9 ' ){ printf( " %c " ,c); scanf( " %c " ,& c); if (c< ' 0 ' ||c> ' 9 ' ){ ...
  • 中缀表达式转后缀表达式实现过程:3. 递归:递归产生的问题:1.括号匹配问题栈例题1算法思想:1)初始一个空栈,顺序读入括号。若是右括号,则与栈顶元素进行匹配·若匹配,则弹出栈顶元素并进行下一个元素·若不匹配...
  • 中缀表达式后缀表达式的转换是堆栈应用的典型例子。通过只允许操作‘+’,‘-’,‘*’,‘/’,并坚持优先级法则,即可实现该操作。 1. 规则 假设读入的中缀表达式是正确的。 当读到操作数时,立即输出。 操作符...
  • 首先中缀表达式转后缀表达式(逆波兰表达式)需要用到一个栈来辅助实现。下面有几条规则(抄的网友的,哈哈哈自己也重新整理了一下) 具体转换方式: 首先的优先级我把它分为( > ÷ > × > - > + 将...
  • 从书上看到的讲起最近(半年内 )在看《大话...然而中缀转后缀表达式的规则,书上写的似乎有些疏漏。后缀表达式求值规则(《大话数据结构》)中缀转后缀规则(《大话数据结构》)当尝试了之后发现,上面的描述没有...
  • #include #include #include #include #define MAX_EXPRESSION_LENGTH ...(1+2)*3*(1+2) 12+3*12+* ((1+2)*2)+(3+4*(5+6)) 12+2*3456+*++ 缺陷 目前只能输入可带括号的+、*运算符,且操作数必须是个位数的有效表达式
  • //用于指向字符串(中缀表达式)的指针 //声明两个栈,一个float型,一个char型 //表达式中操作数存在一个栈内,运算符存入一个栈内 //top1,top2用于指向两个栈的栈顶 float s1[maxSize];int top1=-1; char ...
  • 一、先将中缀表达式转为后缀表达式 规则: 遇到数字:直接输出 遇到左括号:直接入栈 ...举例:有中缀表达式:A+B*(C-D)-E/F,怎么转后缀表达式呢 步骤1:遇到A,输出A 栈:空 步骤2:遇到+,入栈...
  • 中缀表达式转后缀表达式-C语言,Java C语言: #include <stdio.h> #include <stdlib.h> #include <string.h> #define STACK_INIT_SIZE 100 // 存储空间初始化分配量 #define STACKINCREMENT 10 /...
  • C语言中缀表达式转后缀表达式 I 通常,用户输入的表达是为中缀表达式,通过算法,将中缀表达式转化为后缀表达式,然后利用栈存储操作数,遇到operator,弹出栈中的操作数进行相应的运算后再圧栈,直至表达式运算...
  • 中缀表达式转后缀表达式c语言

    千次阅读 多人点赞 2018-06-29 19:32:43
    中缀表达式是一个通用的算术或逻辑公式表示方法, 操作符是以中缀形式处于操作数的中间,是人们常用的算术表示方法。后缀表达式指的是不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,...
  • 前天看到有人给我很久之前写的一篇博客《C语言::将中缀表达式转换为后缀表达式并计算结果》指出了一个BUG. 今天闲的没事,就把BUG修复一下,一看那代码写的,不忍直视,那个BUG更是让我啼笑皆非... 这就是传说中的成长吧...
  • 1.将中缀表达式转换为后缀表达式: (1) 初始化两个栈:运算符栈S1和储存中间结果的栈S2; (2) 从左至右扫描中缀表达式; (3) 遇到操作数时,将其压入S2; (4) 遇到运算符时,比较其与S1栈顶运算符的优先级: Ø (4-...
  • C语言写的中缀转后缀程序...简单易懂适合初学数据结构的人参考

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 183
精华内容 73
关键字:

c语言中缀表达式转后缀表达式

c语言 订阅