精华内容
下载资源
问答
  • C语言后缀表达式计算--For初学者

    千次阅读 2018-09-26 20:19:25
    上次写了中缀转后缀,这次来计算后缀表达式的值,书接上文click here。 思路很简单,先扫描输入的后缀表达式,遇到数字就进栈,遇到运算符就出两个栈顶的元素运算,运算的结果再入栈。直到扫描完,并且栈内只剩下一...

    上次写了中缀转后缀,这次来计算后缀表达式的值,书接上文click here
    思路很简单,先扫描输入的后缀表达式,遇到数字就进栈,遇到运算符就出两个栈顶的元素运算,运算的结果再入栈。直到扫描完,并且栈内只剩下一个元素,进行输出。
    描绘的可能不清楚,直接上代码:

    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define MAX 100
    typedef int ElemType;
    typedef struct node {
      ElemType date;
     struct node *next;
    } StackNode;
    
    void InitStack(StackNode **p) {//栈的声明
        (*p)=NULL;
    }
    
    int StackEmpty(StackNode *p) {//如果栈是空的返回0;不空返回1
        if(p==NULL)
            return 0;
        return 1;
    }
    
    void Push(StackNode **top, ElemType x) {//入栈操作
       StackNode *p;
       p=(StackNode *)malloc(sizeof(StackNode));
       p->date=x;
       p->next=*top;
       *top=p;
    }
    
    void Pop(StackNode **top, ElemType *x) {//出栈操作
        StackNode *p;
        if(*top==NULL)
            printf("Stack is empty!\n");
        else{
            *x=(*top)->date;
            p=*top;
            *top=(*top)->next;
            free(p);
        }
    
    }
    
    int Calc(char *s) {
        StackNode *p;
        InitStack(&p);
         ElemType x1,x2;
        int i=0,x;
        while(s[i])//进行四则运算
        {
            if(s[i]>='0'&&s[i]<='9')
                Push(&p,s[i]-48);
            else{
                Pop(&p,&x1);
                Pop(&p,&x2);
                if(s[i]=='+')
                    Push(&p,x1+x2);
                if(s[i]=='-')
                    Push(&p,x1-x2);
                if(s[i]=='*')
                    Push(&p,x1*x2);
                if(s[i]=='/')
                    Push(&p,x1/x2);
            }
            i++;
        }
        return p->date;
    }
    
    int main() {
      // (5+3)*2+(6+3) = 25
      char str[100] = "53+2*63++";//读者可以自行更改
      int rst;
      rst = Calc(str);
      printf("the results is: %d\n", rst);
      return 0;
    }
    
    

    本人能力有限,运行时难免有bug,请正确输入,输入的数要在10以内,因为字符只能识别一个,为了方便,我在主函数中定义了后缀表达式,读者可以自行更改
    附上结果运行图:
    在这里插入图片描述

    展开全文
  • C语言后缀表达式求值

    千次阅读 2018-12-16 23:06:48
    后缀表达式求值的算法是  遍历后缀表达式,如果遇到运算数,那么运算数入栈 如果遇到运算符,那么弹出栈里面两个元素,先弹出的是右运算数,后弹出的是左运算数,计算运算结果,然后将结果入栈。最后遍历到后缀...

    后缀表达式求值的算法是 

    遍历后缀表达式,如果遇到运算数,那么运算数入栈

    如果遇到运算符,那么弹出栈里面两个元素,先弹出的是右运算数,后弹出的是左运算数,计算运算结果,然后将结果入栈。最后遍历到后缀表达式末尾,当结果只有一个元素时,就是答案

    #define  _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include "LinkStack.h"
    
    int IsNumber(char c)
    {
    	return c >= '0' && c <= '9';
    }
    
    
    typedef struct MYNUM
    {
    	LinkNode node;
    	int val;
    
    }MyNum;
    
    int Caculate(int left, int right, char c)
    {
    	int ret = 0;
    	switch (c)
    	{
    	case '+':
    		ret = left + right;
    		break;
    	case '-':
    		ret = left - right;
    		break;
    	case '*':
    		ret = left * right;
    		break;
    	case '/':
    		ret = left / right;
    		break;
    
    	default:
    		break;	
    	}
    	return ret;
    }
    
    int main()
    {
    	// 后缀表达式
    	char str[50] = "831-5*+";
    	char *p = str;
    	LinkStack* stack = Init_LinkStack();
    	while (*p != '\0')
    	{
    		if (IsNumber(*p))
    		{
    			MyNum* num = (MyNum*)malloc(sizeof(MyNum));
    			num->val = *p - '0';
    			Push_LinkStack(stack, (LinkNode*)num);
    		}
    		else
    		{
    			MyNum* temp = (MyNum*)Top_LinkStack(stack);
    			int rightNum = temp->val;
    			Pop_LinkStack(stack);
    			free(temp);
    			temp = (MyNum*)Top_LinkStack(stack);
    			int leftNum = temp->val;
    			Pop_LinkStack(stack);
    			free(temp);
                
    			int ret = Caculate(leftNum, rightNum, *p);
    
    			MyNum* num = (MyNum*)malloc(sizeof(MyNum));
    			num->val = ret;
    			Push_LinkStack(stack, (LinkNode*)num);
    			
    		}
    		p++;
    	}
    	if (Size_LinkStack(stack) == 1)
    	{
    		MyNum* num = (MyNum*)Top_LinkStack(stack);
    		printf("运算结果是%d\n", num->val);
    		Pop_LinkStack(stack);
    		free(num);
    	}
    	//释放栈
    	FreeSpace_LinkStack(stack);
    	system("pause");
    }

    使用的栈是前面写的企业链式栈

    展开全文
  •  最后得到的结果就是 一个反向的 后缀表达式 */ #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 
    

     

    展开全文
  • 中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 中缀转后缀 需要建一个操作符栈op和一个字符数组expop栈存放操作符字符数组用来存放转换以后的后缀表达式...
  • C语言中,将中缀表达式转成后缀表达式,并计算它的结果,具体的思路如下: 1、定义两个栈,numStack用于存放运算对象,最后存放运算结果的,fuStack用于存放运算符号的 2、从左到右遍历字符串 3、如果当前的字符是...

    在C语言中,将中缀表达式转成后缀表达式,并计算它的结果,具体的思路如下:
    1、定义两个栈,numStack用于存放运算对象,最后存放运算结果的,fuStack用于存放运算符号的
    2、从左到右遍历字符串
    3、如果当前的字符是一个数字,那么先不要着急将其转成数字,然后压入到numStack中,因为考虑到多位数字的情况,所以需要从当前下标开始遍历,一直遍历到第一个运算符出现,那么这时候才可以将运算符前面的数字转成字符串。然后调用atoi,将字符串转成一个数字。这时候,将这个数字输出,同时将其压入到numStack中。
    4、如果当前的字符是一个字符,那么这时候需要分几种情况进行讨论:

    (1)如果栈为空或者当前符号是一个左括号,直接将当前符号压入到fuStack中
    (2)否则,如果栈顶符号是一个左括号,那么直接将当前符号压入到fuStack中
    (3)否则,如果当前符号是一个右括号,那么需要将从fuStack中跳出字符,并输出这
    个字符,然后从numStack中跳出两个数字,进行相应的运算,将运算结果压numStack
    中,重复(3)操作,直到fuStack的栈顶符号是一个左括号,那么这时候,将左括号从
    fuStack中跳出,注意不需要输出
    (4)否则,当前符号是一个普通运算符的时候,那么这时候,需要比较当前符号和栈 
      顶符号的优先级,如果当前的符号优先级大于栈顶符号的优先级,那么直接将当前符
    号压入到fuStack中,否则,当前符号的优先级小于等于栈顶符号的优先级,那么需要将
    栈顶符号跳出,并输出,然后从numStack中跳出两个数字,进行相应的运算,然后将
    运算结果压入到numStack中,重复这个步骤,直到当前符号的优先级大于栈顶符号的优
    先级才可以将当前符号压入到fuStack中
    

    5、遍历完之后,操作还没有结束,还需要判断fuStack是否为空,如果不为空,那么就从fuStack中跳出栈顶元素,并将其输出,同时,将从numStack中跳出两个数字,进行相应的运算,将运算结果压入到numStack中,重复5的操作,直到fuStack为空。
    6、这时候,上述操作都完成之后,这时候numStack的栈顶元素就是整个表达式的运算结果,将其输出即可。

    题目的链接:
    https://pintia.cn/problem-sets/434/problems/5893
    对应的代码:

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #define MAX_SIZE 21
    #define ERROR 0
    #define OK 1
    typedef struct Num{
        int msg[MAX_SIZE];
        int top;
    }numStack;
    void initStack(numStack *num){
        num->top = 0;
    }
    
    int push(numStack *num,int e){
        if(num->top == MAX_SIZE)
            return ERROR;
        num->msg[num->top++] = e;
        return OK;
    }
    int pop(numStack *num,int *e){
        if(num->top == 0)
            return ERROR;
        *e = num->msg[--num->top];
        return OK;
    }
    int getTop(numStack *num,int *e){
        if(num->top == 0)
            return ERROR;
        *e = num->msg[num->top - 1];
        return OK;
    }
    int isEmpty(numStack *num){
        return num->top == 0;
    }
    typedef struct FU{
        char msg[MAX_SIZE];
        int top;
    }fuStack;
    void initFuStack(fuStack *fu){
        fu->top = 0;
    }
    
    int pushFu(fuStack *fu,char e){
        if(fu->top == MAX_SIZE)
            return ERROR;
        fu->msg[fu->top++] = e;
        return OK;
    }
    int popFu(fuStack *fu,char *e){
        if(fu->top == 0)
            return ERROR;
        *e = fu->msg[--fu->top];
        return OK;
    }
    int getFuTop(fuStack *fu,char *e){
        if(fu->top == 0)
            return ERROR;
        *e = fu->msg[fu->top - 1];
        return OK;
    }
    int isFuEmpty(fuStack *fu){
        return fu->top == 0;
    }
    int level(char ch){
        if(ch == '+' || ch == '-')
            return 1;
        else if(ch == '*' || ch == '/')
            return 2;
        else
            return 0;
    }
    int isNum(char ch){
        if(ch >= '0' && ch <= '9')
            return 1;
        return 0;
    }
    int yunsuan(char ch,numStack *num,int *result){
       int a,b;
       pop(num,&a);
       pop(num,&b);//将从栈中跳出两个元素,并将他们的值赋给a、b
       /*
       值得注意的是,必须是b - a,b / a,因为栈式先进后出的结构
       */
       switch(ch){
          case '+':
              *result = b + a;
               break;
          case '-':
              *result = b - a;
               break;
          case '*':
              *result = b * a;
               break;
          case '/':
              if(a == 0){
                return ERROR;//如果不符合运算法则,那么返回ERROR
              }
              *result = b / a;
              break;
       }
       return OK;
    }
    void getPreExpression(numStack *num,fuStack *fu,char *msg){
        int i,result,j,k = 0,a,b,count = 0;//count表示数字的个数
        char ch,tmp,arr[MAX_SIZE];//arr数组用于多位数字的拼接,ch表示当前的字符,tmp表示fuStack的栈顶元素
        for(i = 0; msg[i] != '\0'; i++){
            ch = msg[i];
            if(isNum(ch)){
                j = i;
                k = 0;//重置k
                //拼接数字
                while(isNum(msg[j])){
                    arr[k++] = msg[j];
                    j++;
                }
                arr[k] = '\0';//这一步十分重要
                /*
                这一步将i回到最后一个数字,因为在for循环中还会进行i++的操作,
                如果没有这一步,那么就会导致读取到的字符不全
                */
                i = j - 1;
                a = atoi(arr);//调用atoi方法,从而将这个多位数字的字符串转成整形数字
                count++;
                if(count == 1)
                    printf("%d",a);//如果是第一个数字,那么前面不需要输出一个空格,否则要在前面输出空格
                else
                    printf(" %d",a);
                push(num,a);//将数字压入栈中
            }else{
                //如果是运算符,那么需要分情况讨论
                if(isFuEmpty(fu) || ch == '('){
                    //如果栈为空或者当前字符为左括号,直接将当前符号压入栈中
                    pushFu(fu,ch);
                }else{
                    /*
                    如果栈不为空,那么需要讨论几种情况:
                    ①栈顶是左括号,直接将当前字符压入栈中
                    ②否则,如果当前符号是一个右括号,那么将从栈中跳出栈顶元
                    素,并将其输出,同时将从numStack栈中跳出两个数字,进行相应
                    的运算,之后将运算结果压入到numStack中,重复③的操作,直到
                    栈顶符号式左括号,之后将左括号从fuStack中跳出
                    ③否则,当前字符是普通字符,那么需要判断优先级。如果当前符
                    号的优先级大于栈顶元素的优先级,那么直接入fu栈,否则从符栈
                    中不断跳出栈顶元素,并将其输出,同时将从numStack中跳出两
                    个数字,进行相应的运算,然后将运算结果压入到numStack中,
                    重复此操作,直到当前符号的优先级大于栈顶符号的优先级,才将
                    当前符号压入到fuStack中
                    */
                    getFuTop(fu,&tmp);
                    if(tmp == '('){
                        //如果栈顶元素是一个左括号,那么直接入栈
                        pushFu(fu,ch);
                    }else{
                      //当前的字符不是一个左括号,那么需要判断当前的符号是否为一个右括号
                      if(ch == ')'){
                        getFuTop(fu,&tmp);
                        while(tmp != '('){
                           popFu(fu,&tmp);
                           printf(" %c",tmp);
                           if(!yunsuan(tmp,num,&result)){
                              printf("被除数不可以为0,运算错误!!!\n");
                              return;
                           }
                           push(num,result);//如果运算符合运算法则,那么将运算结果压入到栈中
                           getFuTop(fu,&tmp);
                        }
                        popFu(fu,&tmp);
                      }else{
                         //当前的符号是一个普通符号,那么需要比较优先级
                         label:
                             if(isFuEmpty(fu) || level(ch) > level(tmp)){
                                    //当前符号的优先级大于栈顶符号的优先级,那么直接入栈
                                pushFu(fu,ch);
                             }else{
                                 //当前的符号的优先级小于等于栈顶符号的优先级,那么将栈顶元素从fu栈中跳出并输出
                                popFu(fu,&tmp);
                                printf(" %c",tmp); 
                                if(!yunsuan(tmp,num,&result)){
                                    printf("被除数不可以为0,运算错误!!!\n");
                                    return;
                                }
                                push(num,result);//如果运算符合运算法则,那么将运算结果压入到栈中
                                getFuTop(fu,&tmp);
                                goto label;//利用goto语句,从而实现当前的符号的优先级小于栈顶符号的优先级,然后将其压入
                             }
                      }
                    }
                }
    
            }
        }
        //将num压入到fu栈中
        while(!isFuEmpty(fu)){
             popFu(fu,&tmp);
             printf(" %c",tmp);
             if(!yunsuan(tmp,num,&result)){
             //将进行相应的运算,然后将对应的运算结果赋值给result
                printf("被除数不可以为0,运算错误!!!\n");
                return;
             }
             push(num,result);//如果运算符合运算法则,那么将运算结果压入到栈中
        }
        printf("\n");
        pop(num,&a);//将num中的栈顶元素的值赋给a,并将其删除
        printf("%s的运算结果为%d\n",msg,a);
    }
    int main(){
        numStack *num = (numStack *)malloc(sizeof(numStack));
        fuStack *fu= (fuStack *)malloc(sizeof(fuStack));
        char msg[MAX_SIZE];
        initStack(num);//将栈进行初始化
        initFuStack(fu);
        scanf("%s",msg);//输入字符串
        getPreExpression(num,fu,msg);//将后缀表达式输出,同时将它的运算结果输出
        return 0;
    }
    
    
    

    对应的结果:
    在这里插入图片描述
    在这里插入图片描述

    不足之处:
    1、如果数字是一个小数的情况,则时候就会明显发生错误。
    如下图,输入这样的例子,就直接程序结束了.
    在这里插入图片描述
    2、如果一开始输入的就是负数之类的数的话,那么这时候也是不可以进行运算的。比如-5+6等诸如这样的例子,不可以进行运算。

    如果有什么好的建议,请大家指正哈!

    展开全文
  •   之前一个好兄弟问我表达式计算的一个程序,这个主要锻炼栈的使用。但是他向我提出了一个问题,如果多位数计算,好像常规的表达式转化就不灵了。即常规的程序只能计算10以下的数字,对于这个问题进行下探索。  ...
  • 第二步,读出后缀表达式并进行计算;边转换边计算的算法;此算法的基本思路是将中缀表达式按照转换后缀的表达;首先,用一个char数组将中缀表达式读入,对数组;为了方便计算计算 一、设计思想 两种
  • 大家好,C语言中自加自减——最简单的运算符操作了,也是前后缀——最容易搞混的语法,今天把它搞得明明白白。在前缀运算符中,例如 ++a,这个表达式的运算结果等价...需要注意的是,++a 在实际表达式计算的时候,...
  • C语言实现表达式计算

    2010-04-21 10:40:30
    本段程序为以课程的作业(数据结构),有两段程序(中缀转后缀计算表达式,直接计算两种),完全用turbo c编写,兼容性良好(不存在turbo c上能运行,在vc上报错的现象)!当时做的时候费了很多脑经,现在分享出来,...
  • C语言 : 中缀表达式 计算求值、后缀表达式 计算求值、中缀表达式 转 后缀表达式
  • C语言中缀表达式转化为后缀表达式

    千次阅读 2018-12-12 17:18:51
    #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;...//后缀表示法计算时候的思路!!!先把元素推到栈中,每碰到一个 char stack[50]; char output[50];...
  • //进行子表达式计算 if(flag==0){ printf("被除数为零"); return 0; } s1[++top1]=result;//计算结果存入栈顶 return 1; } //计算表达式的函数 float getResult(char exp[]){ int i=0;//用于指向...
  • 后缀表达式计算 请使用已定义好的栈完成后缀表达式计算: (1)如果是操作数,直接入栈 (2)如果是操作符op,连续出栈两次,得到操作数x 和 y,计算 x op y,并将结果入栈。 后缀表达式示例如下: 931-3*+102/+ ...
  • c语言后缀表达式

    2020-03-25 18:17:44
    后缀表达式计算请使用已定义好的栈完成后缀表达式计算: (1)如果是操作数,直接入栈 (2)如果是操作符op,连续出栈两次,得到操作数x 和 y,计算 x op y,并将结果入栈。后缀表达式示例如下: 9 3 1 - 3 * + 10 2 /...
  • 因为数据结构老师布置了栈的后缀表达式实验,经过思考,有以下反思。 中缀表达式转换为后缀表达式 关于括号,直接将括号里面的符号加入后缀表达式。 关于数字,直接推入后缀表达式 遇到±符号,如果栈为空或者栈顶...
  • 输入常规表达式后,自动转换成后缀表达式,并计算结果。C语言实现,原创代码,欢迎下载。
  • 使用c语言实现后缀表达式计算器

    千次阅读 2016-06-16 23:10:39
    使用栈来进行后缀表达式计算,流程:从前向后读取后缀表达式的项目,遇到数值压入栈中,遇到运算符pop出栈顶的两项做运算,运算结果再放入栈中直到= 例子:求后缀表达式4x*2x*a-c*+=? 1.把4和x压入栈中接下来...
  • 本实验取材于浙江大学《数据结构》,计算后缀表达式,关键在于理解堆栈的工作顺序 //堆栈的应用案例--表达式求值 //表达式求值的基本步数 //1当读入的是一个运算数时,把它被压入栈中; //2当读入的是一个运算符时,...
  • 编写完整程序,将中缀表达式翻译成后缀表达式。表达式由操作数 ( 变量 ) 、操作 ( 运算符 ) 以及小括弧 “ ( ” 和 “ ) ” 组成,其中: 1)操作包括算术运算、关系运算和逻辑运算三类; 2)操作数为单个字符或...
  • 利用后缀表达式计算中缀表达式的值.数据结构 花费了我2周的时间才完成的 数据结构 c语言 MFC,是用MFC做的,,该程序功能强大,健壮性很强,对于错误输入有提示,程序完全正确,解压既可以运行
  • 将由数字和四则运算符组成的后缀表达式变换为中缀表达式。 输入的后缀表达式包含的运算符不超过15个。 要求转换后的中缀表达式中不应出现不必要的括号。 例如,整个表达式两端的括号要省略,不影响原计算结果的括号...
  • 0x00数据结构——C语言实现(栈) 栈的实现 /* 栈(tack)是限制插入和删除只能在一个位置上进行的表,该位置是表的末端,叫做栈的顶(top)。 对栈的基本操作有Push(进栈)和Pop(出栈)。 Functions: ...
  • 从书上看到的讲起最近(半年内 )在看《大话数据结构》,上个星期在栈这一节看到了后缀表达式用于计算的神奇力量。于是用Python试着实现了一下(功底太差,导致花了很长时间)。后缀表达式求值很容易实现,基本就是...
  • 通过把“中缀转后缀”和“后缀求值...实现对中缀表达式直接求值,新算法是直接扫描后缀表达式 (支持 + - * / ^ 五种运算) 输入格式: 共1行,为1个字符串,即一个中缀表达式, 其中每个数字或符号间由一个空格隔开。

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 207
精华内容 82
关键字:

c语言后缀表达式计算

c语言 订阅