精华内容
下载资源
问答
  • 计算后缀表达式——C语言实现

    千次阅读 2018-07-07 17:56:49
    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,...

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

    在命令行中输入: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语言

    千次阅读 多人点赞 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;
    }

    展开全文
  • 7-2 中缀表达式转换为后缀表达式(pta/C语言) 所谓中缀表达式,指的是运算符处于操作数的中间(例:3 * ( 4 + 2 )),中缀表达式是人们常用的算术表示方法,但中缀表达式不容易被计算机解析,因为既要考虑运算符的...

    7-2 中缀表达式转换为后缀表达式(C语言)

    所谓中缀表达式,指的是运算符处于操作数的中间(例:3 * ( 4 + 2 )),中缀表达式是人们常用的算术表示方法,但中缀表达式不容易被计算机解析,因为既要考虑运算符的优先级,还要考虑括号的处理。但中缀表达式仍被许多程序语言使用,因为它符合人们的普遍用法。后缀表达式,指的是不包含括号,运算符放在两个操作数的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,也不需要考虑括号)。

    给出一个中缀表达式,请将其转换为后缀表达式并输出。

    输入格式:

    只有一行,是一个长度不超过1000的字符串,表示一个中缀表达式。表达式里只包含±*/与小括号这几种符号。其中小括号可以嵌套使用。运算符、操作数之间用一个空格分隔,数据保证输入的操作数中不会出现负数,保证除数不会为0。

    输出格式:

    输出对应的后缀表达式。运算符、操作数之间用一个空格分隔,但行尾无多余空格。

    输入样例:

    3 * ( 4 + 2 )

    输出样例:

    3 4 2 + *

    C实现

    #include<stdio.h>
    #include<stdlib.h>
    
    
    typedef struct Node *list;
    struct Node{
    	char data[1001];
    	int top;//设置为从0~top;top为最后元素下标
    	
    };
    
    
    //入栈;
    void push(list s,char ch){
    	(s->top)++;
    	s->data[s->top]=ch;
    	
    }
    //出栈;
    char pop(list s){
    	if(s->top==-1)
    		return '0';
    	(s->top)--;
    	return (s->data[s->top+1]);
    }
    
    
    int main(){
    	char str[1002];
    	char ch;
    	int loc=0;
    	gets(str);
    	list ps=(list)malloc(sizeof(struct Node));//存待处理的字符串
    	ps->top=-1;
    	while(str[loc]!='\0'){//字符串结尾跳出
    		ch=str[loc];
    		//遇到数字打印数字
    		if(ch>='0'&&ch<='9'){
    			while(ch!=' '){
    				printf("%c",ch);
    				loc++;
    				ch=str[loc];
    				//如果结尾为数字
    				if(str[loc]=='\0')break;
    			}
    			printf(" ");
    			if(str[loc]=='\0')break;
    			loc++;
    			ch=str[loc];
    			
    		}
    		//处理运算符
    		if(ch=='('){
    			push(ps,ch);
    		}else if(ch=='+' || ch == '-'){
    			//如果ps栈为空,或遇到(跳出
    			while(ps->top!=-1 && ps->data[ps->top]!='('){
    				printf("%c ",pop(ps));
    			}
    			push(ps,ch);
    		}else if(ch == '*'  || ch == '/'){
    			while(ps->top!=-1 && ps->data[ps->top]!='(' && ps->data[ps->top]!='+' && ps->data[ps->top]!='-'){
    				printf("%c ",pop(ps));
    			}
    			push(ps,ch);
    		}else if(ch==')'){
    			while(ps->data[ps->top]!='('){
    				printf("%c ",pop(ps));
    			}
    			pop(ps);
    		}
    		loc++;
    		if((str[loc])=='\n')
    			break;
    	}
    	while(ps->top!=-1){
    		//设置打印格式
    		if(ps->top==0){
    			printf("%c",pop(ps));}
    		else{
    			printf("%c ",pop(ps));
    		}
    	}
    	return 0;
    }
    

    主要思想

    这个题的主要思想就是遇到")“括号,就返回找”(",当然要边找边处理括号里的运算符。没遇到就按±*/的优先级输出就可了。

    结语

    我在开始做这个题时,理解错误。以为要先输出所有数字然后输出所有运算符。后来过不了在网上搜索了一下中缀表达式转换为后缀表达式的格式才恍然。

    展开全文
  • 那么什么是中缀表达式和后缀表达式呢? 通俗地来说,中缀表达式就是我们平常用到的表达式的方式,比如说: 1+2x(3-4) 而后缀表达式呢?则是计算机容易识别的,但是对于人来说有点难受: ...

    我们再来复习一下堆栈(Stack)这个数据结构,堆栈是有一定约束的线性表,插入和删除操作都作用在栈顶(Top)位置。

    我们既可以通过数组顺序实现堆栈,也可以通过链表链式实现堆栈,具体情况具体分析。

    那么什么是中缀表达式后缀表达式呢?

    通俗地来说,中缀表达式就是我们平常用到的表达式的方式,比如说: 

    1+2x(3-4)

    而后缀表达式呢?则是计算机容易识别的,但是对于人来说有点难受:

    1234-x+

    这就是上面的表达式用后缀法来表达,这样的表示方法有什么好处呢?因为在中缀表达式中,我们从头往后读,如果读到了运算符号,没有办法立即进行运算,因为后面可能有更高的优先级的运算符号,所以简单地从左到右的计算时不可行的。但是在后缀表达式中,我们读到一个符号以后就可以马上和该符号之前的两个数一起做运算,不需要判别运算符的优先级,这就是后缀表达式的好处。

    那么如何将中缀表达式转换为后缀表达式呢?我们就需要用到堆栈这个数据结构。

    通过上面的例子可以看到,后缀表达式和中缀表达式的数字相对位置是不改变的,有变化的只有运算符的位置。

    而运算符的输出则需要根据前后运算符的优先级来看,有可能在得到了后一个运算符的时候,才知道要输出前一个运算符,所以堆栈就很符合这个特点。

    具体关键点是:依次从头读取中缀表达式各项:

    1.如果读取到了空格,直接跳过;

    2.如果读取到了换行符(\n),认为读取到了表达式的结尾;

    2.如果读取到了运算数字,直接输出即可;

    3.如果读取到了左括号,直接压入栈中;

    4.如果读取到了右括号,舍弃右括号,并出栈输出符号,直到遇到了左括号,并把左括号舍弃;

    5.如果读取到了运算符,a.如果栈为空,直接插入;b.栈不空则判断运算符之前是否是左括号,如果是就直接把该运算符进栈。

    c.否则判断优先级是否大于栈顶运算符,如果大于,则进栈。如果小于,则栈顶元素出栈并输出,并再次和新的栈顶运算符比较。直到该运算符大于栈顶运算符 或 栈空了 为止。

    下面上代码:

    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
     
    //用一个结构体来绑定一个运算项和其优先级
    typedef struct Number number;
    struct Number{ 
        char c;//运算数或运算符
        int priority;//优先级
    };
    /*
     各项的类型 优先级
     数字        0
     + -        1
     * /        2
     ( )        3
    
     */
    
    //链栈的节点
    typedef struct StackNode * stack;
    struct StackNode{
        number* data;
        stack next;
    };
    
    //栈的生成方法
    stack makeStack(){
        stack s = (stack)malloc(sizeof(struct StackNode));
        s->data = (number*)malloc(sizeof(struct Number));
        s->next = NULL;
        return s;
    }
    
    //判断栈是否空
    bool isEmpty(stack s){
        return s->next==NULL;
    }
    //入栈
    bool Push(stack s, number* x){
        stack newnode = (stack)malloc(sizeof(struct StackNode));
        newnode->data = x;
        newnode->next = s->next;
        s->next = newnode;
        return true;
    }
    //出栈
    char Pop(stack s){
        if (isEmpty(s)) {
            return -1;
        }
        stack temp=s->next;
        char back = temp->data->c;
        s->next = temp->next;
        free(temp);
        return back;
        
    }
    
    //中缀转后缀方法
    void FromMiddleToPost(){
    
        char c= '\0';//用来接收读取到的字符
        int count=0;//记录数组内的元素个数
        number num[100];//结构体数组 用来记录读取到的中缀表达式并给各项附上优先级
        while (1) {
            scanf("%c",&c);//根据读取到的各项做具体处理
            if (c==' ') {//空格的情况 直接跳过
                continue;
            }else if(c=='+' || c=='-'){
                num[count].c = c;
                num[count++].priority = 1;
            }else if (c=='*' || c== '/'){
                num[count].c = c;
                num[count++].priority = 2;
            }else if (c=='('){
                num[count].c = c;
                num[count++].priority = 3;//左括号
            }else if (c==')'){
                num[count].c = c;
                num[count++].priority = 4;//右括号
            }else{//数字的情况
                num[count].c = c;
                num[count++].priority = 0;
            }
            if (c=='\n') {//读取到回车 结束输入
                break;
            }
        }
        num[count].c = '\0';//数组的最后放入\0
        
        stack s = makeStack();//创建栈
    
        //开始从num数组中读取各种并转化成后缀表达式
        for (int i = 0 ; i<count; i++) {
            if (num[i].c == '\n') {//扔掉回车符
                continue;
            }
            if (num[i].priority==0) {//读取到数字 直接输出
                printf("%c",num[i].c);
            }else{
                if (isEmpty(s)) {//空表的情况下 无论什么运算符 直接插入
                    Push(s, &num[i]);
                }else{
                    if (num[i].priority == 3) {//处理左右括号的情况
                        Push(s, &num[i]);
                    }else if (num[i].priority == 4){//右括号
                        char temp = Pop(s);
                        printf("%c",temp);
                        while (s->next!=NULL && temp!='(') {
                            temp = Pop(s);
                            if (temp!='(') {
                                printf("%c",temp);
                            }
                        }
                    }else if (s->next->data->priority<num[i].priority) {//后插入的优先级 比 栈顶的优先级高
                        Push(s, &num[i]);
                    }else{//后插入的优先级 小于等于 栈顶元素
                        while (s->next!=NULL && s->next->data->priority>=num[i].priority) {//弹出栈 直到栈顶元素的优先级 小于 当前元素的优先级
    
                            if (s->next->data->priority == 3) break;//当栈顶字符是'('时 直接入栈即可 
                            char temp = Pop(s);
                            printf("%c",temp);
                        }
                        Push(s, &num[i]);
                    }
                }
            }
        }
        while (s->next!=NULL) {//弹出栈内剩余的运算符
            char temp = Pop(s);
            printf("%c",temp);
        }
        printf("\n");
    }
    
    
    int main(){
    #ifdef DEBUG
        printf("input:\n");
    #endif  
        FromMiddleToPost();
        
        return 0;
    }
    

    展开全文
  • 以下是用c语言实现中缀表达式到后缀表达式的转换的代码。本文仅讨论转换,不涉及计算。实际上如果了解了栈是如何在这上面应用,计算和前缀、中缀、后缀的相互计算和转换便简单了许多。对于三只种表达方式的转换,...
  • 2、计算后缀表达式的结果。 首先先明白几个问题: 1、为什么要转换为后缀表达式?因为后缀表达式容易实现计算机计算结果。(可以百度一下后缀表达式,又称逆波兰式) 2、怎么把中缀表达式转换为后缀表达式? 3、...
  • 中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 1中缀转后缀 需要建一个操作符栈op和一个字符数组expop栈存放操作符字符数组用来存放转换以后的后缀...
  • //进行子表达式计算 if(flag==0){ printf("被除数为零"); return 0; } s1[++top1]=result;//计算结果存入栈顶 return 1; } //计算表达式的函数 float getResult(char exp[]){ int i=0;//用于指向...
  • 输入常规表达式后,自动转换成后缀表达式,并计算结果。C语言实现,原创代码,欢迎下载。
  • 2、计算后缀表达式的结果。 首先先明白几个问题: 1、为什么要转换为后缀表达式?因为后缀表达式容易实现计算机计算结果。(可以百度一下后缀表达式,又称逆波兰式) 2、怎么把中缀表达式转换为后缀表达式? 3、...
  • 将由数字和四则运算符组成的后缀表达式变换为中缀表达式。 输入的后缀表达式包含的运算符不超过15个。 要求转换后的中缀表达式中不应出现不必要的括号。 例如,整个表达式两端的括号要省略,不影响原计算结果的括号...
  • 表达式计算C语言实现

    2010-10-18 23:58:52
    本程序利用了栈这么一个常用的数据结构实现了算术表达式中缀与后缀的转换,以及完成了计算
  • C语言 : 中缀表达式 计算求值、后缀表达式 计算求值、中缀表达式 转 后缀表达式
  • 后缀表达式计算 请使用已定义好的栈完成后缀表达式计算: (1)如果是操作数,直接入栈 (2)如果是操作符op,连续出栈两次,得到操作数x 和 y,计算 x op y,并将结果入栈。 后缀表达式示例如下: 931-3*+102/+ ...
  • 因为数据结构老师布置了栈的后缀表达式实验,经过思考,有以下反思。 中缀表达式转换为后缀表达式 关于括号,直接将括号里面的符号加入后缀表达式。 关于数字,直接推入后缀表达式 遇到±符号,如果栈为空或者栈顶...
  • 所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右新进行(不用考虑运算符的优先级)。 如:3*(5–2)+7对应的后缀表达式为:...
  • 中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 中缀转后缀 需要建一个操作符栈op和一个字符数组expop栈存放操作符字符数组用来存放转换以后的后缀表达式...
  • 逆波兰表达式 这个主要是对栈的应用,如果不了解栈的同学先去了解一下栈哦,如果了解了,就当这句话不存在; 是数字的话直接入栈; 遇到运算符的话出栈2个数字进行运算,前者对后者进行运算; 运算后的结果...
  • 在栈应用之中缀转后缀表达式C语言版) 这篇文章中已经讲了如何把中缀表达式转化为后缀表达式,这一篇就讲如何计算后缀表达式计算比转换容易得多得多了。C++代码实现下载 java代码实现下载 (备用下载地址 )步骤...
  • ::iterator b = v.begin(); b < v.end();...}// 计算后缀表达式的值,仅支持加减乘除运算、操作数为非负整数的表达式。int postfix_eval(const char * postfix){const size_t N = strlen(postfix);if...
  • 利用后缀表达式计算中缀表达式的值.数据结构 花费了我2周的时间才完成的 数据结构 c语言 MFC,是用MFC做的,,该程序功能强大,健壮性很强,对于错误输入有提示,程序完全正确,解压既可以运行
  • 【数据结构C语言学习打卡-栈】进制转换/多个字符后缀表达式计算/Hanoi塔 先码下代码,后面跟进分析 运行结果 后缀表达式 Hanoi塔 进制转化 #include <stdio.h> #include <stdlib.h> #include <...
  • 通过把“中缀转后缀”和“后缀求值...实现对中缀表达式直接求值,新算法是直接扫描后缀表达式 (支持 + - * / ^ 五种运算) 输入格式: 共1行,为1个字符串,即一个中缀表达式, 其中每个数字或符号间由一个空格隔开。
  • 0x00数据结构——C语言实现(栈) 栈的实现 /* 栈(tack)是限制插入和删除只能在一个位置上进行的表,该位置是表的末端,叫做栈的顶(top)。 对栈的基本操作有Push(进栈)和Pop(出栈)。 Functions: ...
  • C语言后缀表达式计算--For初学者

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

空空如也

空空如也

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

后缀表达式计算c语言

c语言 订阅