精华内容
下载资源
问答
  • 精品文档 一设计思想 计算算术表达式可以用两种方法实现 1.中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 1中缀转后缀 需要建一个操作符栈op和一个字符...
  • 表达式计算C语言实现

    2010-10-18 23:58:52
    本程序利用了栈这么一个常用的数据结构实现了算术表达式中缀与后缀的转换,以及完成了计算
  • 设计一个能够计算表达式的程序,要求能够对包含加、减、 乘、除、括号运算符、与或非运算法运算符的表达式能够检查表达式是否合法,对于错误的表达式要能够给出错误的原因
  • Problem Description The most important activity of ACM is the GSM network. As the mobile phone operator, ACM must build its own transmitting stations. It is very important to compute the exact ...
  • 用两种方式实现表达式自动计算 - PAGE 2 - 设计思想 计算算术表达式可以用两种方法实现 1.中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 中缀转后缀 ...
  • 计算后缀表达式——C语言实现

    千次阅读 2018-07-07 17:56:49
    //创建一个新栈,用于计算n的阶乘 Stack m; Createstack(m); float i,n,item = 1; printf("请输入一个数字:"); scanf("%f",&n) ; for (float i = n; i >= 1; i--) push(m, i); while (m.top != m...

    程序相对简单易懂,运行程序,

    在命令行中输入:123+*#(注意:由于输入字符,以‘#’结束)

    输出:5.000000

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct
    {
    	float *base;
    	float *top;
    	int StackSize;
    }Stack;
    
    //创建一个栈,100为Maxsize,#define无法定义 
    void Createstack(Stack &s)
    {
    	s.base=(float *)malloc(100 * sizeof(float));
    	s.top=s.base;
    	s.StackSize=100;
    	
    }
    
    //栈顶指针 
    float top(Stack s)
    {
    	if(s.top==s.base)
    	{
    		return -1;
    		printf("error!\n");
    		//栈满               
    	}
    	return *(s.top-1);
    }
    
    // 入栈程序 
    void push(Stack &s,float elem)
    {
    	if(s.top-s.base>=s.StackSize)
    	{
    		//扩展栈空间 
    		s.base=(float *)realloc(s.base,(s.StackSize+10)*sizeof(float));
    		s.top=s.base+s.StackSize;
    	    s.StackSize+=10;
    	}
    	 *s.top++ = elem;
    }
    
    //出栈程序 
    void pop(Stack &s)
    {
    	if(s.top==s.base)
    	{
    		//栈空 
    		printf("error!\n");
    		return ;
    	}
    	s.top--;
    }
    
    //判断输入运算符 
    int operate(char c)
    {
    	switch(c)
    	{
    	case '+' :return 1;
    	case '-' :return 1;
    	case '*' :return 1;
    	case '/' :return 1;
    	default :return 0;
    	}
    }
    
    //输入表达式 
    float cal(float a,float b,char c)
    {
    	switch(c)
    	{
    	case '+' :return a+b;
    	case '-' :return a-b;
    	case '*' :return a*b;
    	case '/' :return a/b;
    	}
    }
    
    //主函数 
    int main()
    {
    	float a,b,result;
    	Stack s;
    	Createstack(s);
    	char c1='0';
        printf("输入后缀表达式:"); 
    	while(c1!='#')
    	{
    		c1=getchar();
    
    		if(!operate(c1))
    		{
    			
    			push(s,(float) (c1-48));
    		}
    		else
    		{
    			b=top(s);
    			pop(s);
    			a=top(s);
    			pop(s);
    			result=cal(a,b,c1);
    			push(s,result);
    		}
    	
    	}
    	printf("%f\n",result);
    	system("pause");
    
    	//创建一个新栈,用于计算n的阶乘 
    	Stack m;
    
    	Createstack(m);
    
    	float i,n,item = 1;
    
    	printf("请输入一个数字:");
    
    	scanf("%f",&n) ;
    
    	for (float i = n; i >= 1; i--)
    
    		push(m, i);
    
    	while (m.top != m.base){
    
    		item= top(m) * item;
    
    		pop(m);
    
    	}
    
        printf("n的阶乘为:");
    
    	printf("%f",item) ;
    
    
    	return 0;
    }
    

    展开全文
  • 数据结构课程设计,用两种方式实现表达式的自动计算
  • 结构清晰地介绍了用栈计算表达式的方法,附带详细的注释,希望像能对 和我一样入门级的朋友们有所帮助
  • 中缀表达式计算 c语言链表实现 1题目 输入一个中缀算术表达式计算其结果。对输入的表达式,做如下假设: (1)只考虑+、-、*、/这四种运算符,中缀表达式中只有一种括号(); (2)输入的中缀表达式中数字只有...

    中缀表达式的计算 c语言链表实现

    1题目
    输入一个中缀算术表达式,计算其结果。对输入的表达式,做如下假设:
    (1)只考虑+、-、*、/这四种运算符,中缀表达式中只有一种括号();
    (2)输入的中缀表达式中数字只有整数,没有小数;
    (3)假定输入表达式是合法的。
    2测试用例
    中缀表达式:(1)1+(2-3)*4+4/2 (2)a+(b-c)*d
    3算法
    建立两个栈,分别储存数字和运算符,在读取表达式的时候,凡是遇到数字,就将其压栈,压入stack1,当遇到运算符的时候进行判断,若栈为空,进行压栈,若运算符为左括号,也进行压栈,为右括号,则进行计算,计算至左括号处,若为一般的运算符,则与前一个运算符的优先级进行比较,若前一个的优先级高或者相等,则先进行运算,反之,则将该运算符压栈。最后输出数字栈中的数字,即为运算结果。
    4 算法过程的模拟
    例 1+(2-3)*4+4/2

    stack1 stack2

    读取表达式,读取为1,将其存入stack1

    stack1 stack2
    1

    读取第二个,为运算符,此时stack2为空,则直接压栈

    stack1 stack2
    1 +

    读取第三个,为左括号,进行压栈

    stack1 stack2
    1 +
    (

    读取第四个,为数字,对stack1进行压栈

    项目 Value
    1 +
    2 (

    读取第五个,为运算符,与前一个进行运算级的比较,大于左括号,则进行压栈

    stack1 stack2
    1 +
    2 (
    -

    读取第六个,为数字,对stack1进行压栈

    stack1 stack2
    1 +
    2 (
    3 -

    读取第七个,为右括号,则进行运算,运算至左括号处,左括号输出,则有

    stack1 stack2
    1 +
    -1

    读取第八个,为乘号,比较运算优先级,应进行压栈

    stack1 stack2
    1 +
    -1 *

    读取第九个,为数字,对stack1进行压栈

    stack1 stack2
    1 +
    -1 *
    4

    读取第十个,为运算符,比较优先级,发现应进行运算,则有Stack1: stack2:

    stack1 stack2
    1 +
    -4

    继续读取第十个,与前一个优先级进行比较,应进行运算

    stack1 stack2
    -3

    继续读取第十个,此时stack2为空,则进行压栈

    stack1 stack2
    -3 +

    读取下一个,为数字,对stack1压栈,有

    stack1 stack2
    -3 +
    4

    读取下一个,为运算符,比较应压栈,有

    stack1 stack2
    -3 +
    4 /

    读取下一个,为数字,压栈

    stack1 stack2
    -3 +
    4 /
    2

    读取下一个,读取发现多项式结束,则进行运算至结束

    stack1 stack2
    -1

    输出运算结果,为-1。
    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    static int stack1[100];
    static char stack2[100];
    static char str[200];
    static int top1,top2;
    //开创两个栈,strack1储存数字  strack2储存运算符
    //top1 top2 为两个栈的栈顶
    void push1(int str)
    {
        top1++;
        stack1[top1]=str;
    }
    //对数字进行压栈
    void push2(char str)
    {
        top2++;
        stack2[top2]=str;
    }
    //对运算符进行压栈
    int getnum(char str)
    {
        switch(str)
        {
        case ('('):
            return 0;
        case ('.'):
            return 0;
        case ('-'):
            return 1;
        case ('+'):
            return 1;
        case ('/'):
            return 2;
        case ('*'):
            return 2;
        }
    }
    //给予各个运算符运算等级,!注意左括号要最小为避免左括号后的一个运算符直接进行运算
    void operation()
    {
        if(stack2[top2]=='-')
        {
            stack1[top1-1]=stack1[top1-1]-stack1[top1];
            top1=top1-1;
            top2=top2-1;
            return;
        }
        if(stack2[top2]=='+')
        {
            stack1[top1-1]=stack1[top1-1]+stack1[top1];
            top1=top1-1;
            top2=top2-1;
            return;
        }
        if(stack2[top2]=='*')
        {
            stack1[top1-1]=stack1[top1-1]*stack1[top1];
            top1=top1-1;
            top2=top2-1;
            return;
        }
        if(stack2[top2]=='/')
        {
            stack1[top1-1]=stack1[top1-1]/stack1[top1];
            top1=top1-1;
            top2=top2-1;
            return;
        }
    
    }
    //运算函数,根据运算符进行运算
    int main()
    {
        top1=top2=-1;
        printf("请输入中缀表达式(符号使用英文符号):\n");
        scanf("%s",str);
        int i=0;
        for(i=0; str[i]!='\0'; i++);
        str[i]='.';
        str[i+1]='\0';
        i=0;
        while(str[i]!='\0')
        {
            if(str[i]>=48&&str[i]<=57)
            {
                push1(str[i]-48);
                i++;
            }
            else if(top2==-1)
            {
                push2(str[i]);
                i++;
            }
            else
            {
                if(str[i]=='(')
                {
                    push2(str[i]);
                    i++;
                }
                //如果输入的是左括号,进行入栈
                else
                {
                    if(str[i]==')')
                    {
                        while(stack2[top2]!='(')
                            operation();
                        top2=top2-1;
                        i++;
                    }
                    //若输入的为右括号,进行计算,一直计算至左括号处
                    else
                    {
                        if(top2==-1)
                            push2(str[i]);//输入的不是左括号时,判断栈是否为空,为空直接入栈
                        else    //若栈不为空,则进行判断,优先级高于栈顶元素时,进行入栈,反之进行计算
                        {
                            if(getnum(str[i])>getnum(stack2[top2]))
                            {
                                push2(str[i]);
                                i++;
                            }
                            else
                            {
                                operation();
                            }
                        }
    
                    }
                }
            }
        }
        printf("结果是:\n%d",stack1[top1]);
        return 0;
    }
    

    这是我自己写出来的代码,我也是正在学习的学生,供大家参考,若有什么问题,希望可以给我指出,谢谢!

    展开全文
  • 中缀表达式转后缀表达式c语言

    千次阅读 多人点赞 2018-06-29 19:32:43
    后缀表达式指的是不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则)。1、遇到操作数,直接输出。2、如果不是操作数,分为以下几种情况(1)...

    中缀表达式是一个通用的算术或逻辑公式表示方法, 操作符是以中缀形式处于操作数的中间,是人们常用的算术表示方法。

    后缀表达式指的是不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则)

    下面简述转换方法:

    1、遇到操作数,直接输出。

    2、如果不是操作数,分为以下几种情况

    (1)如果操作符栈为空,则入栈。

    (2)如果栈非空,且当前操作符优先级大于栈顶操作符,则入栈;如果当前操作符优先级小或等于栈顶操

             作符,则操作符栈出栈,直到当前操作符优先级大于栈顶操作符。

    (3)如果是左括号'(',则入栈。

    (4)如果是右括号')',则操作符栈一直出栈,把出栈元素放到操作数栈,直到遇到 左括号'('。

    (5)特别注意左括号'('入栈时优先级等于右括号')',入栈后优先级为最小。 

    #include<stdio.h>
    #include<string.h>

    typedef struct node
    {
        char s[310];
        int top;
    }Stack;

    int weight(char ch, int flag)
    {
        if(ch=='+'||ch=='-') return 1;
        if(ch=='*'||ch=='/') return 2;
        if(ch=='('&&flag==1) return 0;
        if(ch=='('&&flag==0) return 3;
    }

    void transform(char str[])
    {
       Stack a;
       a.top=-1;
       int i,f=0,m=strlen(str);
       for(i=0;i<m;i++)
       {
          if(str[i]>='A'&&str[i]<'Z')
          {
              printf("%c",str[i]);
          }
          else
          {
              if(a.top==-1)
              {
                  a.s[++a.top]=str[i];
                  continue;
              }
              if(str[i]==')')
              {
                  while(a.top!=-1&&a.s[a.top]!='(')             //每次进行出栈操作时都要判断栈是否为空,且判断在操作之前。
                            printf("%c",a.s[a.top--]);
                  --a.top;
                  continue;
              }
              if(weight(str[i],0)>weight(a.s[a.top],1))
              {
                  a.s[++a.top]=str[i];
                  continue;
              }
              while(a.top!=-1&&weight(str[i],0)<=weight(a.s[a.top],1))     //每次进行出栈操作时都要判断栈是否为空,
              {                                                                                         //且判断在操作之前。
                 printf("%c",a.s[a.top]);                  //用while循环为不用if语句来比较新读入的操作符与栈顶操作的的权值大小,
                 --a.top;                                       //是因为当新读入的操作符的权值小于栈顶操作符的权值时,也可能小于栈顶
                 f=1;                                            //下一 个操作符的权值
              }
              if(f==1)
              {
                   a.s[++a.top]=str[i];
                   f=0;
              }
          }
       }
       while(a.top!=-1)
       {
           printf("%c",a.s[a.top--]);
       }
    }

    int main()
    {
        char str[310];
        gets(str);
        transform(str);
        return 0;
    }

    展开全文
  • 例如,整个表达式两端的括号要省略,不影响原计算结果的括号要省略。 【输入形式】 程序从标准输入上读入一行字符串,是一个合法的后缀表达式,数字和运算符之间由空格分隔。 其中的数字可以是整数,也可以是带...

    目录

    关于表达式树

    由后缀表达式构建表达式树的方法

    分析题面要求,进行定义

    加括号规则

    AC代码


    C2第三次作业的第一题,题面如下:

    【问题描述】
    将由数字和四则运算符组成的后缀表达式变换为中缀表达式。
    输入的后缀表达式包含的运算符不超过15个。
    要求转换后的中缀表达式中不应出现不必要的括号。
    例如,整个表达式两端的括号要省略,不影响原计算结果的括号要省略。
    【输入形式】
    程序从标准输入上读入一行字符串,是一个合法的后缀表达式,数字和运算符之间由空格分隔。
    其中的数字可以是整数,也可以是带有小数部分的浮点数。
    【输出形式】
    向标准输出打印结果。 输出只有一行,是转换后的中缀表达式,并且 
    1. 各分量(包括括号)紧密输出,不使用空格进行分隔; 
    2. 在转换前后各运算数的出现顺序不变; 
    3. 浮点数保留输入时的小数位数。
    【输入样例】
    4 7 - 2.1 5 + * 7.1 9 - /
    【输出样例】
    (4-7)*(2.1+5)/(7.1-9)
    【时间限制】
    1s
    【空间限制】
    65536KB
    【上传文件】
    上传c语言源程序,文件名为convert.c。

    因为感觉这个还是比较有用的所以单独发一篇好了。毕竟数据结构之后我很少写关于树的代码了(本身也不咋会),而且这题也算是这次里面差不多很复杂的一题了。至于吐槽我写C2第三周的时候再吐槽。

    之前数据结构写过表达式求值,方法是将中缀表达式转换为后缀表达式然后计算,这一步用到的数据结构主要是栈。而且还写过将后缀表达式转换成表达式树。那么接下来这次终于是要写表达式树还原中缀表达式了。不过太久没接触这东西了,所以写这题的时候还是参考了网上的一些内容,并且翻阅了以前写的代码,才完成了这次的作业并且顺利A了。

    关于表达式树

    (1)表达式树的特点:所有叶节点都是操作数,即数字。而其他节点为运算符,在我们这里就是+-*/了。由于这些都是二元运算符,所以这里表达式树是二叉树。

    (2)表达式树的前序遍历为前缀表达式,中序遍历为中缀表达式,后序遍历为后缀表达式。这样我们也能理解(1)中为何叶节点不能为运算符,因为其左右连接的是运算符左边和右边的表达式。

    (3)由后缀表达式构建表达式树最为方便。如果给出了其他表达式,则需要先转换为后缀表达式才能构建。我们这题就不用转换了。

    由后缀表达式构建表达式树的方法

    (1)依次读入每个符号,如果为操作数,我们就建立一个树的节点,并且将其指针压入栈中。

    (2)若符号为运算符,从栈中弹出两棵子树T1和T2,先弹出T1。然后形成一棵一个以该运算符为根的树,T1为右子树,T2为左子树。(栈的特性先进后出,后进先出,所以T1为较后出现的子树,即出现在运算符右边,所以是右子树)将该树压入栈中,继续读取。

    分析题面要求,进行定义

    首先数字可能是整数或浮点数,而且浮点数保留输入时的小数位数,因此1.0000这种不用化简。所以保存时直接用字符串保存即可。

    由此,树的定义如下:

    /*表达式树的定义*/
    struct node {
    	char num[LENGTH];
    	struct node *lchild;
    	struct node *rchild;
    };
    typedef struct node Node;
    typedef struct node* BTNodeptr;

    另外我们需要输出中缀表达式,所以需要的是中序遍历,函数声明如下(命名懒得改了):

    void freeT(BTNodeptr p);	//释放表达式树
    void travel(BTNodeptr p);	//中序遍历,输出中缀表达式以及添加括号
    BTNodeptr buildT(char s[]);	//建立表达式树

    此外还需要栈来保存指针,简易写一下即可。

    /*存放表达式树的指针的栈*/
    BTNodeptr tree[SUM];	
    int top = 0;
    void push(BTNodeptr p) { tree[++top] = p; }
    BTNodeptr pop() { return tree[top--]; }

    加括号规则

    根据题目要求,我们不一定要完全还原表达式的计算过程。例如表达式ab+cde+**,其正确中缀表达式应该为(a+b)*(c*(d+e)),因为后缀表达式是先计算c*(d+e),再将其与a+b相乘的。

    而题目要求是不影响原计算结果的括号要省略,所以我们应该输出(a+b)*c*(d+e)。

    加括号需要满足下面两个判断:

    (1)对于当前节点(非叶节点,即为运算符的节点),若其左节点也为运算符,且其优先级小于当前节点,则为左节点的表达式添加括号。

    优先级小于之时,显然应该添加括号。比如左子树表达式为a-b(这里a不一定为一个数,可能为一个表达式),当前节点为*,那么先计算a-b,应该添加括号,否则会改变运算顺序影响结果。

    优先级用到小于,是因为左子树的表达式在运算符之前计算,如果运算符相等,是不必添加括号的。例如:左子树表达式为a*b,当前节点运算符为/,那么a*b外层无论添加不添加括号都不会影响运算顺序,自然不会影响结果。

    (2)对于当前节点(非叶节点,即为运算符的节点),若其右节点也为运算符,且其优先级小于当前节点,则为右节点的表达式添加括号;若优先级相等,且当前节点运算符为'-'或者'/',则也为右节点的表达式添加括号。

    运算符优先级小于自然好理解。而等于之时需要判断,与左子树不同,这是因为右子树的表达式在运算符之后计算。如果优先级相等,括号是用来表示运算顺序的。我们一开始举了个例子就是如此,ab+cde+**。但是当前节点为*或+时,a*b*c和a*(b*c)虽然改变了运算顺序,但是并不会改变运算结果。而当前节点为-或/,a/b/c和a/(b/c)结果就完全不同了。所以这是这题特殊的地方。

    我们用以下三个函数来判断:

    /*判断符号优先级*/
    bool judge(char s[]);
    bool judgeLeft(char s1[], char s2[]);
    bool judgeRight(char s1[], char s2[]);

    当然,如果题目要求改变,不是“不影响原计算结果的括号要省略”,而是还原原来的表达式的计算顺序,那么添加括号的顺序就不太相同了,需要另加判断。

    而添加括号,我是在中序遍历中完成的。目前我只会写递归版本的,当然用递归来写添加括号当然是简单不少而且清晰明了。非递归版本的遍历还要加括号,可饶了我吧。

    由原始的递归

    void travel(BTNodeptr p)
    {
    	if (p != NULL)
    	{	
                    travel(p->lchild);
    		printf("%s", p->num);
                    travel(p->rchild);
    	}
    }

    改为这个版本:

    void travel(BTNodeptr p)
    {
    	if (p != NULL)
    	{
    		/*若p的左子树上是符号,并且小于p上的符号优先级,则添加括号*/
    		if (p->lchild && judgeLeft(p->num,p->lchild->num))
    		{
    			printf("(");
    			travel(p->lchild);
    			printf(")");
    		}
    		else
    			travel(p->lchild);
    
    		printf("%s", p->num);
    
    		/*若p的右子树上是符号,并且不大于p上的符号优先级,则判断后添加括号*/
    		if (p->rchild && judgeRight(p->num, p->rchild->num))
    		{
    			printf("(");
    			travel(p->rchild);
    			printf(")");
    		}
    		else
    			travel(p->rchild);
    	}
    }

    我自认为还是完成的不错的,看着也不算太复杂,也还是比较好理解。

    AC代码

    上面都是架构,下面则是完整的AC代码,虽然写的还是不好,不过比起大一时候的一团乱麻也算清晰了很多,这也算是一点进步吧(笑)。(大一时候的代码基本现在看不下去)

    也欢迎各位参观的有什么建议来指正。

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #include<stdbool.h>
    #define LENGTH 10007
    #define SUM 512
    
    /*表达式树的定义及函数*/
    struct node {
    	char num[LENGTH];
    	struct node *lchild;
    	struct node *rchild;
    };
    typedef struct node Node;
    typedef struct node* BTNodeptr;
    
    void freeT(BTNodeptr p);	//释放表达式树
    void travel(BTNodeptr p);	//中序遍历,输出中缀表达式以及添加括号
    BTNodeptr buildT(char s[]);	//建立表达式树
    
    /*存放表达式树的指针的栈*/
    BTNodeptr tree[SUM];	
    int top = 0;
    void push(BTNodeptr p) { tree[++top] = p; }
    BTNodeptr pop() { return tree[top--]; }
    
    /*判断符号优先级*/
    bool judge(char s[]);
    bool judgeLeft(char s1[], char s2[]);
    bool judgeRight(char s1[], char s2[]);
    
    int main()
    {
    	char s[LENGTH];
    	BTNodeptr root = NULL;
    
    	fgets(s, LENGTH, stdin);    //不用gets是因为fgets更安全
    	root = buildT(s);
    	travel(root);
    	freeT(root);                //虽然大一很菜很菜,不过记得free这个好习惯还是从大一就有了
                                        //PS:其实是因为没听懂担心内存泄露
    
    	return 0;
    }
    
    
    void freeT(BTNodeptr p)
    {
    	if (p != NULL) {
    		freeT(p->lchild);
    		freeT(p->rchild);
    		free(p);
    		p = NULL;
    	}
    }
    
    /*表达式树特点:若p有左右节点,则p必定为符号位*/
    void travel(BTNodeptr p)
    {
    	if (p != NULL)
    	{
    		/*若p的左子树上是符号,并且小于p上的符号优先级,则添加括号*/
    		if (p->lchild && judgeLeft(p->num,p->lchild->num))
    		{
    			printf("(");
    			travel(p->lchild);
    			printf(")");
    		}
    		else
    			travel(p->lchild);
    
    		printf("%s", p->num);
    
    		/*若p的右子树上是符号,并且不大于p上的符号优先级,则判断后添加括号*/
    		if (p->rchild && judgeRight(p->num, p->rchild->num))
    		{
    			printf("(");
    			travel(p->rchild);
    			printf(")");
    		}
    		else
    			travel(p->rchild);
    	}
    }
    
    
    BTNodeptr buildT(char s[])
    {
    	int i;
    	BTNodeptr p;
    	int a = 0;
    	char temp[LENGTH];
    
    	for (i = 0; s[i] != '\0'; i++)
    	{
    		/*读取到数字,储存*/
    		if ((s[i] >= '0' && s[i] <= '9') || s[i] == '.')
    			temp[a++] = s[i];
    		/*读取到空格,将数字存储*/
    		else if (s[i] == ' ' && a != 0)
    		{
    			temp[a] = '\0';
    			p = (BTNodeptr)malloc(sizeof(Node));
    			strcpy(p->num, temp);
    			p->lchild = NULL;
    			p->rchild = NULL;
    			push(p);
    			a = 0;
    		}
    		/*若为运算符,从栈中弹出T1和T2作为右节点和左节点*/
    		else if(s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/') {
    			p = (BTNodeptr)malloc(sizeof(Node));
    			p->num[0] = s[i];
    			p->num[1] = '\0';
    			BTNodeptr pright = pop();
    			BTNodeptr pleft = pop();
    			p->lchild = pleft;
    			p->rchild = pright;
    			push(p);
    		}
    	}
    	return p;
    }
    
    /*判断s是否为符号*/
    bool judge(char s[])
    {
    	return (s[0] == '+' || s[0] == '-' || s[0] == '/' || s[0] == '*');
    } 
    
    
    /*判断父节点s1的优先级是否比左节点s2高 */
    bool judgeLeft(char s1[], char s2[])
    {
    	if ((s1[0] == '*' || s1[0] == '/') && (s2[0] == '+' || s2[0] == '-'))
    		return true;
    	return false;
    }
    
    /*判断父节点s2的优先级是否大于右节点s2,若相等还需判断父节点是否为'/'或'-' */
    bool judgeRight(char s1[], char s2[])
    {
    	if (s1[0] == '/' && judge(s2))
    		return true;
    	if ((s1[0] == '*' || s1[0] == '-') && (s2[0] == '+' || s2[0] == '-'))
    		return true;
    	return false;
    }

     

    展开全文
  • 基于二叉树的表达式计算C语言

    千次阅读 2017-09-17 21:54:31
    基于二叉树的表达式计算C语言 deran pan, blg-012 1、方法  支持的运算符包括+、-、×、/、(、)、^、sin、cos、tan。不支持括号的嵌套。  计算过程的一个例子如下: 2. 源码如下  expreesion_...
  • //进行子表达式计算 if(flag==0){ printf("被除数为零"); return 0; } s1[++top1]=result;//计算结果存入栈顶 return 1; } //计算表达式的函数 float getResult(char exp[]){ int i=0;//用于指向...
  • 前缀表达式C语言

    千次阅读 2019-09-08 22:14:06
    问题描述 编写一个程序,以字符串方式输入一个前缀表达式,然后计算它的值。 输入格式为:“运算符 对象 1 对象 2”,其中,运算符为“+”(加法)、“-”(减 法)、“*”(乘法) 或“/”(除法),运算对象为不...
  • 7-2 中缀表达式转换为后缀表达式(pta/C语言) 所谓中缀表达式,指的是运算符处于操作数的中间(例:3 * ( 4 + 2 )),中缀表达式是人们常用的算术表示方法,但中缀表达式不容易被计算机解析,因为既要考虑运算符的...
  • 设计思想 计算算术表达式可以用两种方法实现 1.中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 中缀转后缀 需要建一个操作符栈op和一个字符数组expop栈...
  • 数据结构程序(C语言):输入一个算术表达式,由常量、变量、运算符和括号组成(规定:操作数只能为正整数,而操作符只能是+、-、×、/这几个二元运算符,用“#”表示表达式结束),输出对算术表达式计算的结果。...
  • 用两种方式实现表达式自动计算 一设计思想 计算算术表达式可以用两种方法实现 1.中缀转后缀算法 此算法分两步实现 先将算术表达式转换为后缀表达式 然后对后缀表达式进行计算具体实现方法如下 1中缀转后缀 需要建一...
  • 以下是用c语言实现中缀表达式到后缀表达式的转换的代码。本文仅讨论转换,不涉及计算。实际上如果了解了栈是如何在这上面应用,计算和前缀、中缀、后缀的相互计算和转换便简单了许多。对于三只种表达方式的转换,...
  • 输入常规表达式后,自动转换成后缀表达式,并计算结果。C语言实现,原创代码,欢迎下载。
  • 输入常规表达式后,自动转换成中缀表达式,并计算结果。C语言实现,原创代码,欢迎下载。
  • 那么什么是中缀表达式和后缀表达式呢? 通俗地来说,中缀表达式就是我们平常用到的表达式的方式,比如说: 1+2x(3-4) 而后缀表达式呢?则是计算机容易识别的,但是对于人来说有点难受: ...
  • 前言 先来啰嗦几句,身边的朋友,同事都喜欢在博客上记录自己在学习计算机编程技术...对于计算技术,越是深入越越数学挂钩,想达到大神级别,嗯,我是有自知之明的。计算机技术虽然之多,并不需要我们每一个领域每...
  • C语言表达式计算

    2012-02-01 19:52:45
    能够计算如:-5+3,(3+5)*(5+3),sin(3.2)*cos(6.5)/(6*exp(6))等表达式,基本上可以解析C语言的全部表达式,但暂不支持C语言中返回值为int或自变量为2个的函数。
  • int account(char a[],DataType *result) /*表达式计算*/ {  int i,j = 0,f = 0,k = 0,n = 100;  char b[20]; /*用来记录数字串*/  DataType temp = 0,temp1 = 0,temp2 = 0; /*临时数据变量*/  ...
  • C语言 表达式计算

    2014-09-06 01:00:03
    对从键盘输入一个表达式,进行运算,最后输出计算结果。 计算范围:包括一般的算术运算(加、减、乘、除、括号)和常用的函数运算(三角函数、自然指数函数、自然对数函数、绝对值函数、平方根函数)。
  • 2、计算后缀表达式的结果。 首先先明白几个问题: 1、为什么要转换为后缀表达式?因为后缀表达式容易实现计算机计算结果。(可以百度一下后缀表达式,又称逆波兰式) 2、怎么把中缀表达式转换为后缀表达式? 3、...
  • 2、计算后缀表达式的结果。 首先先明白几个问题: 1、为什么要转换为后缀表达式?因为后缀表达式容易实现计算机计算结果。(可以百度一下后缀表达式,又称逆波兰式) 2、怎么把中缀表达式转换为后缀表达式? 3、...
  • c语言中缀表达式计算

    2015-01-03 18:15:23
    利用c语言写的中缀表达式,主要数据结构是栈。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,804
精华内容 1,121
关键字:

表达式计算c语言

c语言 订阅