表达式，转换和计算，用C语言描述－－Part4（源代码）

最新推荐文章于 2022-02-25 21:57:21 发布
最新推荐文章于 2022-02-25 21:57:21 发布
阅读量1k 收藏
点赞数
分类专栏： 其他 文章标签： c 语言 struct output null delete
Program #1
To convert Infix expression to Prefix and Postfix form using Stack
 
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <ctype.h>
 
#define MAX 50
 
     char output[MAX] ;
     char stack[MAX] ;
     char input[MAX] ;
     char *s, *t ; /*pointers to input and output strings*/
     char ch; /*choice*/
     int top; /*Stack top*/
     int l ; /*length of infix string*/
 
     /*Function Prototypes*/
     void Initialize (void);
     void SetExpression (char *);
     char PopFromStack (void );
     void PushOnStack (char);
     int priority (char);
     void ConvertToPrefix (void);
     void ConvertToPostfix (void);
 
void main( )
{
     clrscr( ) ;
     Initialize (  ) ;
     printf ( "/nEnter an expression in infix form: " ) ;
     gets ( input ) ;
     printf ( "/nSpecify output expression type, 1)Prefix 2)Postfix " ) ;
     ch=getch();
     SetExpression (input) ;
     if(ch=='1') /*Infix->Prefix*/
      {
            strrev ( s );
            ConvertToPrefix ( ) ;
            strrev (  output ) ;
            printf ( "/nThe Prefix expression is: " ) ;
      }
     else
      {
       ConvertToPostfix ( ) ;
       printf ( "/nThe Postfix expression is: " ) ;
      }
 
     puts(output);
     getch( ) ;
}
 
void Initialize (void)
{
            top = -1 ;/*Make stack empty*/
            strcpy ( output, "" ) ;
            strcpy ( stack, "" ) ;
            l = 0 ;
}
 
void SetExpression ( char *str )
{
            s = str ;
            l = strlen ( s ) ;
            *( output + l ) = '/0' ;
            t = output;
}
 
/* adds operator to the stack */
void PushOnStack (  char c )
{
            if ( top == MAX - 1 )
             printf ( "/nStack is full./n" ) ;
            else
            {
                        top++ ;
                        stack[top] = c ;
            }
}
 
/* pops an operator from the stack */
char PopFromStack (void )
{
            if ( top == -1 ) /* Stack is empty*/
              return -1 ;
            else
            {
                        char item = stack[top] ;
                        top-- ;
                        return item ;
            }
}
 
 
/* returns the priotity of the operator */
int priority ( char c )
{
            if ( c == '^' ) return 3 ;/*Exponential operator*/
            if ( c == '*' || c == '/' || c == '%' )          return 2 ;
            else if ( c == '+' || c == '-' ) return 1 ;
            else return 0 ;
}
 
/* converts the Infix expression to Prefix form */
void ConvertToPrefix (void)
{
            char opr ;
 
            while ( *( s )  )
            {
                        /*Skip white spaces, if any*/
                        if ( *( s )  == ' ' || *( s )  == '/t' )
                        {
                                    s++    ;
                                    continue ;
                        }
 
                        if ( isdigit ( *( s )  ) || isalpha ( *(
                         s )  ) )/*operands*/
                        {
                                    while ( isdigit ( *( s )  ) || isalpha ( *
                                    ( s )  ) )
                                    {
                                                *( t ) = *( s )  ;
                                                s++   ;
                                                t++ ;
                                    }
                        }
                        if ( *( s )  == ')' )/*Closing Parenthesis*/
                        {
                                    PushOnStack (  *( s ) ) ;
                                    s++    ;
                        }
                        if ( *( s )  == '*' || *( s )  == '+' || *( s ) 
                        == '/' || *( s )  == '%' || *( s )  == '-' || *( s ) 
                        == '^' )
                        {
                                    if ( top != -1 )
                                    {
                                                opr = PopFromStack (  ) ;
                                                while ( priority ( opr ) >
                                                priority ( *( s )  ) )
                                                {
                                                            *( t ) = opr ;
                                                            t++ ;
                                                            opr =
                                                    PopFromStack (  ) ;
                                                }
                                                PushOnStack (  opr ) ;
                                                PushOnStack (  *( s )  ) ;
                                    }
                                    else PushOnStack (  *( s ) ) ;
                                    s++    ;
                        }
                        if ( *( s )  == '(' )/*Opening Parenthesis*/
                        {
                                    opr = PopFromStack (  ) ;
                                    while ( opr != ')' )
                                    {
                                                *( t ) = opr ;
                                                t++ ;
                                                opr =  PopFromStack (  ) ;
                                    }
                                    s++    ;
                        }
            }
            while ( top != -1 )/*While Stack is not empty*/
            {
                        opr = PopFromStack (  ) ;
                        *( t ) = opr ;
                        t++ ;
            }
            t++ ;
}
 
/* converts the infix expr. to postfix form */
void ConvertToPostfix (void)
{
            char opr ;
 
            while ( *( s )  )
            {       /*Skip white spaces, if any*/
                        if ( *( s )  == ' ' || *( s )  == '/t' )
                        {
                                    s++    ;
                                    continue ;
                        }
 
                        if ( isdigit ( *( s )  ) || isalpha ( *(
                         s )  ) )/*Operands*/
                        {
                                    while ( isdigit ( *( s )  ) || isalpha ( *
                                      ( s )  ) )
                                    {
                                                *( t ) = *( s )  ;
                                                s++   ;
                                                t++ ;
                                    }
                        }
                        if ( *( s )  == '(' )/*Opening Parenthesis*/
                        {
                                    PushOnStack (  *( s ) ) ;
                                    s++    ;
                        }
                        if ( *( s )  == '*' || *( s )  == '+' || *( s ) 
                        == '/' || *( s )  == '%' || *( s )  == '-' || *( s ) 
                        == '^' )
                        {
                                    if ( top != -1 )
                                    {
                                                opr = PopFromStack (  ) ;
                                                while ( priority ( opr ) >=
                                                 priority ( *( s )  ) )
                                                {
                                                            *( t ) = opr ;
                                                            t++ ;
                                                            opr =
                                                         PopFromStack (  ) ;
                                                }
                                                PushOnStack (  opr ) ;
                                                PushOnStack (  *( s )  ) ;
                                    }
                                    else PushOnStack (  *( s ) ) ;
                                    s++    ;
                        }
                        if ( *( s )  == ')' )/*Closing Parenthesis*/
                        {
                                    opr = PopFromStack (  ) ;
                                    while ( opr != '(' )
                                    {
                                                *( t ) = opr ;
                                                t++ ;
                                                opr =  PopFromStack (  ) ;
                                    }
                                    s++    ;
                        }
            }
            while ( top != -1 )/*While stack is not empty*/
            {
                        opr = PopFromStack (  ) ;
                        *( t ) = opr ;
                        t++ ;
            }
            t++ ;
}
 
END OF PROGRAM #1
 
 
PROGRAM #2
/*Expression tree: Creation, Conversion and Evaluation.*/
#include<stdio.h>
#include<conio.h>
#include<alloc.h>
#include<math.h>
 
#define MAX 50
 
struct node
{
            struct node* left_child;
            char x;
            struct node* right_child;
} * stack[50];
int top = -1;
 
struct node* CreateExpTreePostfix(char*);
struct node* CreateExpTreePrefix(char*);
 
void preorder(struct node* sr);
void inorder(struct node* sr);
void postorder(struct node* sr);
 
int Evaluate(struct node* sr);
 
void push(struct node**, struct node*);
struct node* pop(struct node**);
 
void Delete_Tree(struct node*);
 
main()
{
            struct node* root;
            char str[50];
            int z;
            char ch;
 
            clrscr();
            printf("Input expression is:/n1)Prefix/n2)Postfix ");
            ch=getche();
            if(ch=='1')
             {
              printf("/nEnter Prefix Expression:");
              gets(str);
              root = CreateExpTreePrefix(str);
             }
            else
              {
               printf("/nEnter Postfix Expression:");
               gets(str);
               root =  CreateExpTreePostfix(str);
              }
 
            printf("/nPrefix Exp.  :");
            preorder(root);
            printf("/nInfix Exp.   :");
            inorder(root);
            printf("/nPostfix Exp. :");
            postorder(root);
 
            z=Evaluate(root);
            printf("/nExpression Evaluated to: %d", z);
 
            Delete_Tree(root);
 
            getch();
 
}
struct node* CreateExpTreePostfix(char* str)
{
            struct node* nleft, * nright, * nodeptr;
            while (*str)
            {
                        nodeptr = (struct node *) malloc(sizeof(struct node));
                        nodeptr->x = *str;
                        if (*str == '+' ||  *str == '-' || *str == '/' ||
                        *str == '*' || *str == '^')
                        {
                                    nright = pop(stack);
                                    nleft = pop(stack);
 
                                    nodeptr->left_child = nleft;
                                    nodeptr->right_child = nright;
                        }
                        else
                        {
                                    nodeptr->left_child = NULL;
                                    nodeptr->right_child = NULL;
                        }
                        push(stack, nodeptr);
                        str++;
            }
 
            return pop(stack);
}
 
struct node* CreateExpTreePrefix(char* str)
{
            struct node* nleft, * nright, * nodeptr;
            strrev(str);
            while (*str)
            {
                        nodeptr = (struct node *) malloc(sizeof(struct node));
                        nodeptr->x=*str;
 
                        if (*str == '+' || *str == '-' || *str == '/' || *str
                        == '*' || *str == '^')
                        {
                                    nleft = pop(stack);
                                    nright = pop(stack);
 
                                    nodeptr->left_child = nleft;
                                    nodeptr->right_child = nright;
 
                        }
                        else
                        {
                                    nodeptr->left_child = NULL;
                                    nodeptr->right_child = NULL;
                        }
                        push(stack, nodeptr);
                        str++;
            }
            return pop(stack);
}
 
void inorder(struct node* sr)
{
            if (sr != NULL)
            {
                        inorder(sr -> left_child) ;
 
            /* print the data of the node whose left child is NULL or the path
             has already been traversed */
                        printf("%c", sr ->x) ;
 
                        inorder(sr -> right_child) ;
            }
}
 
 
void preorder(struct node* sr)
{
            if (sr != NULL)
            {
                        /* print the data of a node */
                        printf("%c", sr -> x) ;
                        /* traverse till left child is not NULL */
                        preorder(sr -> left_child) ;
                        /* traverse till right child is not NULL */
                        preorder(sr -> right_child) ;
            }
}
 
 
 
void postorder(struct node* sr)
{
            if (sr != NULL)
            {
                        postorder(sr -> left_child) ;
                        postorder(sr -> right_child) ;
                        printf("%c", sr -> x) ;
            }
}
 
 
void push(struct node** stack, struct node* ptr)
{
            if (top == MAX - 1)
                        printf("/nStack is full./n") ;
            else
            {
                        top++ ;
                        stack[top] = ptr ;
            }
}
 
/* pops an operator from the stack */
struct node* pop(struct node** stack)
{
            if (top == -1)
            {
                        printf("Stack is empty/n") ;
                        return -1 ;
            }
            else
            {
                        struct node* ptr = stack[top] ;
                        top-- ;
                        return ptr ;
            }
}
 
 
int Evaluate(struct node* sr)
{
   int x,y,z;
            if (sr != NULL)
            {
                        if (    sr->x == '+' ||       sr->x == '-' ||    sr-
                        >x == '/' ||  sr->x == '*' ||   sr->x == '^'      )
                        {
                          x = Evaluate(sr -> left_child) ;
                          y = Evaluate(sr -> right_child) ;
 
                          switch(sr->x)
                           {
                             case  '+' : z=x+y;      break;
                             case  '-' : z=x-y;      break;
                             case  '*' : z=x*y;      break;
                             case  '/' : z=x/y;      break;
                             case  '^' : z=pow(x,y); break;
 
                           }
                          return z;
                        }
                        return (sr -> x - 48) ;
            }
}
void Delete_Tree(struct node * root)
{
    if(root!=NULL)
    {
            Delete_Tree(root->left_child);
            Delete_Tree(root->right_child);
            free(root);
    }
}
 
END OF PROGRAM #2

pc2s
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言-第三章-运算符和表达式完整版资料.ppt
11-14
C语言-第三章-运算符和表达式完整版资料.ppt
表达式计算c语言源程序实例,C语言-数据结构-栈运用实例-计算器源代码
weixin_39738380的博客
05-22 148
1. 目标编写一个支持浮点数及括号的加减乘除计算器。html输入：中缀表达式git输出：后缀表达式及计算结果express注意：该代码在VS13上运行经过。数组运行示例：url 2. 实现流程spa 2.1 中缀表达式转换为后缀表达式请参考以下连接：点击打开连接code3. 源代码htm#include#include#include#define stacksize 30#define stac...
表达式，转换和计算，用C语言描述－－Part3
pc2s的专栏
08-18 1211
表达式，转换和计算，用C语言描述－－Part3（关于表达式的所有你应该知道的东西）其余转换 所有剩余的转换都可以轻易地用二分表达式树来完成。事实上，上面的两种转换，也即中缀->前缀和中缀>后缀，也能用二分树来做，但是技巧性太强，而用栈来完成就容易得多。现在我们继续讲解，首先对二分表达式树下一定义。二分表达式树表达式树是严格的二分树，叶节点存放操作数，非叶节点存放运算符，根节点存放用
c语言指针b 和b j,c语言精华 ------ 指针和数组
weixin_35882236的博客
05-21 295
一．指针。它的本质是地址的类型。在许多语言中根本就没有这个概念。但是它却正是C灵活，高效，在面向过程的时代所向披靡的原因所在。因为C的内存模型基本上对应了现在von Neumann(冯·诺伊曼)计算机的机器模型，很好的达到了对机器的映射。不过有些人似乎永远也不能理解指针【注1】。注1：Joel Spolsky就是这样认为的，他认为对指针的理解是一种aptitude，不是通过训练就可以达到的指针可以...
c语言---刷题02
weixin_51912875的博客
02-09 985
1.输入数字n，按顺序打印出从 1 到最大的 n 位十进制数 比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999 int* printNumbers(int n, int* returnSize ) { *returnSize = pow(10, n) - 1; //确定最大的数字 int *arr = (int *)malloc(sizeof(int)*(*returnSize)); //申请足够大小的空间 for (int i = 0; i &l.
Java 实例 - 利用堆栈将中缀表达式转换成后缀表达式源代码-详细教程.zip
08-09
Java 实例 - 利用堆栈将中缀表达式转换成后缀表达式源代码-详细教程.zip
编译原理课程作业C语言实现- 计算器， 内含表达式的计算（中缀转后缀）+源代码+文档说明
最新发布
01-07
编译原理课程作业C语言实现-- 计算器， 内含表达式的计算（中缀转后缀）+源代码+文档说明 - 小白不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的课程设计，代码都测试ok，都是运行成功后才上传...
大学计算机C语言课程-第六章-数据类型和表达式.ppt
05-24
大学计算机C语言课程-第六章-数据类型和表达式.ppt该文档详细且完整，值得借鉴下载使用，欢迎下载使用，有问题可以第一时间联系作者~
数据结构课程设计-表达式求值C语言.zip
10-26
数据结构课程设计-表达式求值C语言.zip数据结构课程设计-表达式求值C语言.zip数据结构课程设计-表达式求值C语言.zip数据结构课程设计-表达式求值C语言.zip数据结构课程设计-表达式求值C语言.zip数据结构课程设计-...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8719
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3123
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 3587
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1486
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
清除浮动的五种方法
weixin_52212950的博客
02-22 2170
为什么要清除浮动？因为往往浮动后的子元素因为脱离了标准流，不能自动撑起父元素的高度，所以会对后续布局产生影响，对此清除浮动不如理解为清除浮动产生的影响更为合理。 例如：我们设置了两个盒子如图所示，粉色为父盒子，只有宽度没有高度，蓝色盒子有宽有高，粉色盒子的高由蓝盒子的高度撑开。 但是给蓝色的子盒子设置了左浮动后，脱离了标准流，无法再撑开粉盒子，可以看到粉盒子高度变成了0； 清除浮动有五种方法： 直接设置父元素的高度 额外标签法 单伪元素法 双伪元素法 ove.
HTML实现学习网站首页
做技术，坚持才是最重要的，一时的热情只是暂时的进步
02-20 3894
项目访问 reset.css /* http://meyerweb.com/eric/tools/css/reset/ v2.0 | 20110126 License: none (public domain) */ html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del
C语言经典小游戏之----推箱子
嵌入式技术开发
02-25 4562
在进行推箱子的实验中，可以使用对应的API函数来改变对应箱子的颜色，也需要根据，人在移动的过程中，可以通过方向键，并改变对应的颜色，从而实现控制人物的目的。 代码实现如下： #include<stdio.h> #include<stdlib.h> #include<string.h> #include<windows.h> #include<conio.h> int x = 0, y = 0; //存储当前使用的...
关于Dubbo的mock=true降级无法调用降级类ServiceMock的解决方案
weixin_45754452的博客
02-25 1274
问题 消费者使用mock=“true”，想调用TestServiceMock进行服务降级无法调用 原因 我的项目结构如下，首先要知道服务降级代码应该是谁执行的，服务降级是服务消费者也就是controller包处对应的服务执行的，因为我只是测试dubbo怎么使用，所以并没有分多模块，但完全可以把一个包理解为一个模块，再看下面配置文件 为什么可以把一个包当成一个模块呢，因为我把配置文件的scan改成controller包然后启动一个服务器，即消费者，如果把scan改成service则可以启动服务提供者服务器
Vue---Vue基础
前端与计算机相关知识的分享，博主的qq523235674
02-25 1339
一.Vue概述 二.Vue的基本使用 2.1Vue.js之hello world 基本实例 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <title>Document</title> </.
输入表达式并进行计算用C语言完整代码
06-10
以下是用C语言实现输入表达式并进行计算的完整代码： ```c #include #include #define MAX_SIZE 100 // 定义表达式的最大长度 // 栈结构体 typedef struct { int top; // 栈顶指针 double data[MAX_SIZE]; //...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值