中序表达式--C语言实现

最新推荐文章于 2022-05-23 17:07:46 发布
最新推荐文章于 2022-05-23 17:07:46 发布
阅读量478 收藏
点赞数
分类专栏： C/C++/Lua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nizqsut/article/details/52148908
版权
主体程序：

/* calc_expr.c */

/************************************************************************
 *                                                                      
 *                        计算中序表达式demo程序
 * nizqsut
 ************************************************************************/
#include
#include

#include "../libdc/stackar.h"
#include "../libdc/fatal.h"
#include "../include/expression.h"


static char infix[] = "a+b*c+(d*e+f)*g";

static char subfix[sizeof(infix)+1];



//static const char digitals[] = {'1','2','3',''
//}

static TOKEN_PRIO get_token_prio(char token){

    TOKEN_PRIO token_prio;
    
    if (is_digital(token)) {
        return DIGITAL;
    }
    if (is_char(token)) {
        return CH_TOKEN;
    }
    switch(token) {
        case '+':
        case '-':
            token_prio = ADD_SUB;
            break;

        case '*':
        case '/':
            token_prio = MULTI_DIV;
            break;

        case '(':
            token_prio = LEFT_BRACKET;
            break;

        case ')':
            token_prio = RIGHT_BRACKET;
            break;
       
        default:
            token_prio = UNKOWN_TOKEN;
    }
   
    return token_prio;
}



int expr_input(char *buf_in, int buf_len){
   
    char ch;
    int in_len;

    in_len = 0;
    while ( (ch = getchar()) != 0x0a ) {
        buf_in[in_len++] = ch;
        if (in_len == (buf_len - 1)) {
            Error("Goto max input!\n");
            return -1;
        }
    }
    buf_in[in_len] = 0;

    return 0;
}

/* 将字符串表达式转化为中缀表达式 */
int string2infix(char *str, TOKEN *tokens, int max_token){

    int value;
    //int token_cnt;
    TOKEN_PRIO    token_prio;
    TOKEN_PRIO    old_token_prio;

    old_token_prio = UNKOWN_TOKEN;
    //token_cnt = 0;
   
    value = 0;
    while (*str) {
        switch( (token_prio = get_token_prio(*str) ) ) {

        case DIGITAL:
                value *= 10;
                value += ch_to_dig(*str);
                old_token_prio = token_prio;
            break;

        case ADD_SUB:
        case MULTI_DIV:
        case LEFT_BRACKET:
        case RIGHT_BRACKET:
           

            if (DIGITAL == old_token_prio) {
                if ( !tokens) {
                    Error("Not tokens for use!");
                    return -1;
                }
                tokens->prio = DIGITAL;
                tokens->value = value;
                value = 0;
//                tokens = tokens->next;
                tokens++;
            }

            if ( !tokens) {
                Error("Not tokens for use!");
                return -1;
            }
            tokens->prio = token_prio;
            tokens->value = *str;
            //tokens = tokens->next;
            tokens++;
            break;

        default:
            Error("Unkown token type!");
            return -1;
        }

        str++;
        old_token_prio = token_prio;
    }

    if (DIGITAL == old_token_prio) {
        if ( !tokens) {
            Error("Not tokens for use!");
            return -1;
        }
        tokens->prio = DIGITAL;
        tokens->value = value;
    }

    return 0;
}

static void out2subfix(char ch){

    static int subfix_index = 0;

    subfix[subfix_index++] = ch;
}

static void token_copy(TOKEN *src, TOKEN *target){
    target->prio = src->prio;
    target->value = src->value;
}

/* 将中缀表达式编程后缀表达式 */
int infix2subfix(TOKEN *infix_token, TOKEN *subfix_token, STACK_OP stack_op){

    //STACK_OP stack_op;
//    TOKEN_PRIO    token_prio;
//    TOKEN_PRIO    last_token_prio;
    TOKEN    token;

    stack_op->make_empty(stack_op);
   
    while (infix_token->prio != UNKOWN_TOKEN) {
       
        switch( infix_token->prio) {
            case DIGITAL:
            //case CH_TOKEN:
                    //out2subfix(infix[i++]);
                //if (subfix_token) {
                    token_copy(infix_token,subfix_token++);
                    //subfix_token = subfix_token->next;
                    //subfix_token++;
                //}else{
                //    Error("Subfix token flow!");
                //    return -1;
                //}
                break;

            case MULTI_DIV:
            case ADD_SUB:
                while (1) {
                    if (stack_op->is_empty(stack_op)) {
                        stack_op->push(stack_op, *infix_token);
                        break;
                    }else{
                        /* 如果栈里面的操作符优先级比当前操作符优先级高或相等，则其弹出栈 */
                        if ( (stack_op->get_top(stack_op)).prio >= infix_token->prio ) {
                            //if (subfix_token) {
                                token = stack_op->pop(stack_op);
                                token_copy(&token, subfix_token++);
                                //token_copy( &(stack_op->pop(stack_op)), subfix_token++);
                            //    subfix_token = subfix_token->next;
                            //}else{
                            //    Error("Subfix token flow!");
                            //    return -1;
                            //}
                        }else{
                            stack_op->push(stack_op,*infix_token);
                            break;
                        }
                    }

                }
                break;

            case LEFT_BRACKET:
                stack_op->push(stack_op,*infix_token);
                break;

            case RIGHT_BRACKET:
                do {
                    if ( LEFT_BRACKET == (stack_op->get_top(stack_op)).prio ) {
                        stack_op->pop(stack_op);
                        break;
                    }
                    //if (subfix_token) {
                        token = stack_op->pop(stack_op);
                        token_copy(&token, subfix_token++);
                        //token_copy( &stack_op->pop(stack_op), subfix_token++);
                    //    subfix_token = subfix_token->next;
                    //}else{
                    //    Error("Subfix token flow!");
                    //    return -1;
                    //}
                } while(1);
                break;

            default:
                Error("Unkown token prio!\n");
                break;
        }
        infix_token++;
        //infix_token = infix_token->next;
    }

    while (!stack_op->is_empty(stack_op)) {
        //if (subfix_token) {
            //token = stack_op->get_top(stack_op);
            token = stack_op->pop(stack_op);
            token_copy(&token, subfix_token++);
            //token_copy( &stack_op->pop(stack_op), subfix_token++);
        //    subfix_token = subfix_token->next;
        //}else{
        //    Error("Subfix token flow!");
        //    return -1;
        //}
        //out2subfix(stack_op->pop(stack_op));
    }
   
    /* subfix 结束标志为 prio == UNKOWN_TOKEN*/
    subfix_token->prio = UNKOWN_TOKEN;
    return 0;
}

static int
calc_token(TOKEN *token, int operater, int operator){

    int        result;
   
    switch(token->prio) {
        case ADD_SUB:
        case MULTI_DIV:
            break;

        default:
            Error("Unkown operater type!");
        //    return -1;
            break;
    }

    switch(token->value) {
        case '+':
            result = operater + operator;
            break;

        case '-':
            result = operater - operator;
            break;

        case '*':
            result = operater * operator;
            break;

        case '/':
            result = operater / operator;
            break;

        default:
            //Error("Unkown operator value!");
            //return -1;
            break;
    }

    return result;
}
/************************************************************************/
/* 计算后缀表达式方法:                                                  */
/*       遇到操作数，压栈；遇到操作符，弹出需要的操作数做运算             */
/************************************************************************/
int calc_subfix(TOKEN *subfix, STACK_OP stack_op){

    int operater;    //操作数
    int operator;    //被操作数
    TOKEN    token;

    stack_op->make_empty(stack_op);

    while (subfix->prio != UNKOWN_TOKEN) {
        switch(subfix->prio) {
            case DIGITAL:
                stack_op->push(stack_op, *subfix);
                break;

            case ADD_SUB:
            case MULTI_DIV:
                operator = stack_op->pop(stack_op).value;
                operater = stack_op->pop(stack_op).value;
                token.value = calc_token(subfix,operater,operator);
                token.prio = DIGITAL;
                stack_op->push(stack_op,token);
                break;

            default:
                Error("Unkown token type!");
                break;
        }
        subfix++;
    }

    if ( !stack_op->is_empty(stack_op)) {
        token = stack_op->pop(stack_op);
        printf("Expression value equal:%d\n",token.value);
    }else{
        Error("Subfix error!");
        return -1;
    }
   
    return 0;
}

#define EXPR_INPUT_BUF_LEN    256
#define MAX_TOKEN    16
/*
"a+b*c+(d*e+f)*g"的后缀表达式为：
        a b c * + d e * f + g * +
"3+5*6+(18*24+17)/12" 后最表达式为：
        3 5 6 * + 18 24 * 17 + 12 / +       
*/               
int calc_expr(void){

    char buf_in[EXPR_INPUT_BUF_LEN]; //= "3+5*6+(18*24+17)/12";// = "11+12*13+(14*15+16)*17";
    STACK_OP stack_op;
    TOKEN    infix[MAX_TOKEN];
    TOKEN    subfix[MAX_TOKEN];
    int    i;

    if ( !(stack_op = stack_init(MAX_TOKEN)) ) {
        Error("Stack initial fail!");
        goto exit_calc_expr;
    }

    /*
    if ( !(infix = malloc(sizeof(struct TOKEN) * MAX_TOKEN)) ) {
        Error("Out of space!");
        goto free_stack_mem;
    }
    if ( !(subfix = malloc(sizeof(struct TOKEN) * MAX_TOKEN)) ) {
        Error("Out of space!");
        goto free_infix_mem;
    }*/

    for (i = 0; i < MAX_TOKEN; i++) {
        infix[i].prio = UNKOWN_TOKEN;
        subfix[i].prio = UNKOWN_TOKEN;
    }

    if (expr_input(buf_in,EXPR_INPUT_BUF_LEN)) {
        Error("Expression input error!");
        goto free_all_mem;
    }/**/

    if (string2infix(buf_in,infix,MAX_TOKEN)) {
        Error("String2infix error!");
        goto free_all_mem;
    }

    if (infix2subfix(infix,subfix,stack_op)) {
        Error("infix2subfix error!");
        goto free_all_mem;
    }

    if (calc_subfix(subfix,stack_op)) {
       
    }
free_all_mem:
//    free(subfix);
//free_infix_mem:
//    free(infix);
//free_stack_mem:
    stack_release(stack_op);
exit_calc_expr:
    return 0;
}

//----------------------------------------------------------------------------
表达式相应的头文件：

/* expression.h */

#ifndef __EXPRESSION_H__
#define __EXPRESSION_H__

#define true    1
#define false    0

#define is_digital(c)    ( ((c) >= '0') && ((c) <= '9') ) ? true : false

#define is_char(c)        ( ((c) >= 'a') && ((c) <= 'z') ) ? true : false

#define ch_to_dig(ch)    ( (ch) - '0' )

typedef enum {
    UNKOWN_TOKEN = 0,
    LEFT_BRACKET,
    RIGHT_BRACKET,
    DIGITAL,
    CH_TOKEN,
    ADD_SUB,
    MULTI_DIV,
//    LEFT_BRACKET,
//    RIGHT_BRACKET,
}TOKEN_PRIO;

typedef struct TOKEN{
    int    value;
    TOKEN_PRIO    prio;
    //TOKEN    *next;
}TOKEN;

//----------------------------------------------------------------------------
堆栈头文件：

/* stackar.h */
#ifndef __STACKAR_H__
#define __STACKAR_H__

/* 打开边界检查功能 */
#define    STACK_DEBUG       

#define MIN_STACK_SIZE    8
#define EMPTY_TOS    -1

#define STACK_TRUE    1
#define STACK_FALSE 0

#define EXPR_STACK
//--
//#ifndef element_type

//#ifdef EXPR_STACK
#include "../include/expression.h"
typedef struct TOKEN    element_type;
//#else
//typedef int element_type;
//#endif

//#endif
//--


typedef struct _STACK_OP *STACK_OP;

struct _STACK_OP{
    void    *priv;
    void    (*make_empty)(STACK_OP stack_op);
    int        (*is_full)(STACK_OP stack_op);
    int        (*is_empty)(STACK_OP stack_op);
    void    (*push)(STACK_OP stack_op, element_type element);
    element_type (*pop)(STACK_OP stack_op);
    element_type (*get_top)(STACK_OP stack_op);
    int (*get_capacity)(STACK_OP stack_op);
}_STACK_OP;

STACK_OP stack_init(int stack_capacity);
void stack_release(STACK_OP stack_op);

#endif


//----------------------------------------------------------------------------
堆栈的实现：

/* stackar.c */

#include "stackar.h"
#include "fatal.h"

struct _STACK_INFO {
    int capacity;
    int top_pos;    // top of stack
    element_type    *array;
}_STACK_INFO;

typedef struct _STACK_INFO *STACK_INFO;

static void make_empty(STACK_OP stack_op){
   
    STACK_INFO stack_info;
   
    stack_info = stack_op->priv;
    stack_info->top_pos = EMPTY_TOS;
}

/* If stack is full return STACK_TRUE, else return STACK_FALSE. */
static int is_full(STACK_OP stack_op){

    STACK_INFO stack_info;
   
    stack_info = stack_op->priv;

    return ( (stack_info->top_pos + 1) == stack_info->capacity ) ? STACK_TRUE : STACK_FALSE;
}

/* If stack is empty return STACK_TRUE, else return STACK_FALSE. */
static  int is_empty(STACK_OP stack_op){

    STACK_INFO stack_info;

    stack_info = stack_op->priv;

    return (stack_info->top_pos == EMPTY_TOS) ? STACK_TRUE : STACK_FALSE;
}

/* 先栈指针加一，再入栈。属于满栈 */
static void push(STACK_OP stack_op, element_type element){

    STACK_INFO stack_info;
   
    stack_info = stack_op->priv;

#ifdef STACK_DEBUG
    if (STACK_TRUE == stack_op->is_full(stack_op)) {
        Error("Stack have full. Can't push!");
        return;
    }
#endif

    stack_info->array[++stack_info->top_pos] = element;

    return;
}

/* 先出栈，再使栈指针减一 */
static element_type pop(STACK_OP stack_op){

    STACK_INFO stack_info;
   
    element_type    element;
   
    stack_info = stack_op->priv;

#ifdef STACK_DEBUG
    if (STACK_TRUE == stack_op->is_empty(stack_op)) {
        Error("Stack is empty. Cann't pop!");
        //return ;    /* avoid complier warning. */
    }
#endif
   
    element = stack_info->array[stack_info->top_pos];
    stack_info->top_pos--;
    return element;

    //return stack_info->array[stack_info->top_pos--];
}

/* 返回栈顶元素 */
static element_type get_top(STACK_OP stack_op){
    STACK_INFO stack_info;
   
    stack_info = stack_op->priv;

    return stack_info->array[stack_info->top_pos];
}

/* 返回整个栈容量 */
static int get_capacity(STACK_OP stack_op){
    STACK_INFO stack_info;
   
    stack_info = stack_op->priv;

    return stack_info->capacity;
}

/* 分配栈所需要的内存，初始化栈操作的函数指针
 * 如果初始化失败返回空指针
 */
STACK_OP stack_init(int stack_capacity){
   
    STACK_INFO    stack_info;
    STACK_OP    stack_op;

    if (stack_capacity < MIN_STACK_SIZE) {
        Error("Stack size is too small");
    }

    if ( !(stack_op = malloc(sizeof *stack_op)) ) {
        Error("Out of space!!");
        goto error_exit;
    }
   
    if ( !(stack_info = malloc(sizeof(*stack_info))) ) {
        Error("Out of space!!");
        goto free_stack_op;
    }
    if (!(stack_info->array=(element_type *)malloc( sizeof(element_type) * stack_capacity))) {
        Error("Out of space!!");
        goto free_stack_info;
    }

    stack_info->capacity = stack_capacity;
    stack_op->priv        = (void *)stack_info;
    stack_op->make_empty = make_empty;
    stack_op->push        = push;
    stack_op->pop        = pop;
    stack_op->is_empty    = is_empty;
    stack_op->is_full    = is_full;
    stack_op->get_capacity = get_capacity;
    stack_op->get_top    = get_top;
   
    stack_op->make_empty(stack_op);

    return stack_op;

free_stack_info:
    free(stack_info);
free_stack_op:
    free(stack_op);
error_exit:
    return NULL;
}

void stack_release(STACK_OP stack_op){

    STACK_INFO stack_info;
   
    stack_op->make_empty(stack_op);

    stack_info = stack_op->priv;
    free(stack_info->array);
    free(stack_info);
    free(stack_op);
   
    return;
}
 
<script>window._bd_share_config={"common":{"bdSnsKey":{},"bdText":"","bdMini":"2","bdMiniList":false,"bdPic":"","bdStyle":"0","bdSize":"16"},"share":{}};with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?v=89860593.js?cdnversion='+~(-new Date()/36e5)];</script>
阅读(446) | 评论(0) | 转发(0) |
0

上一篇：AVL树--C语言实现

下一篇：三年还没看完一部《数据结构与算法分析 C描述》

相关热门文章
给主人留下些什么吧！~~
评论热议
钱德勒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中序计算式的计算器模型C语言实现
私のBookShelf
12-14 363
#include <stdio.h> #include <stdlib.h> #include <math.h> #include <ctype.h> #include <stdbool.h> #define INIT_SIZE 100 #define INCRE_SIZE 10 #define OPERAND 1 #define OPERATOR 2 char _BUFFER[1000]; int _POS; char myGetchar(
C语言实现中缀表达式求值算法,算法3-4：表达式求值 （C++代码）
weixin_42641869的博客
05-25 1543
解题思路:问题描述：输入由整型分量和操作符组成的中缀表达式，输出其后缀表达式和运算的结果。整型分量：十进制数。操作符：( , ) , + , - , * , / 。如输入3*(5-8/2)+7，输出 3 5 8 2 / - * 7 +，结果是10;输入3-(1/4+7)*3 ,输出 3 1 4 / 7 + 3 * -，结果是 -18.75；输入3*4/5*(5-7)+4，输出 3 4 * 5 / ...
用C语言写出的关于中序表达式求值的源代码
09-04
中序表达式求值是对数据结构中堆栈的应用，在此提供源代码，并写出了清楚的注释
C语言链表之中序表达式
木有
08-14 896
C语言链表之中序表达式 #include #include typedef struct s_node { int data; struct s_node *next; }s_list; typedef s_list* link; link operater=NULL;/* operater stack*/ link operand=NULL;/*operand stack*/ li
c语言条件表达式 中序,中序表达式--C语言实现
weixin_33514582的博客
05-23 140
#include #include "../libdc/stackar.h"#include "../libdc/fatal.h"#include "../include/expression.h"static char infix[] = "a+b*c+(d*e+f)*g";static char subfix[sizeof(infix)+1];//static const char digit...
用栈实现中序表达式的计算
05-22
用栈实现，输入中序表达式，计算数值，可以有括号
中序表达式转后序表达式
10-22
中序表达式转后序表达式，思路较为清晰，注释详细。。。
用栈求前序，中序，后序表达式的值
无
05-23 1317
用栈求前序，中序，后序表达式的值
用C语言写一个 用中序表达式创建二叉树的代码表达式用+-*/并可以求值
最新发布
06-01
好的，下面是用C语言实现的中序表达式创建二叉树并求值的代码： ```c #include #include // 定义二叉树节点结构体 typedef struct TreeNode { char data; // 节点值 struct TreeNode* left; // 左子树指针 ...
中缀表达式的计算 c语言链表实现
weixin_45841571的博客
06-20 2143
中缀表达式的计算 c语言链表实现 1题目 输入一个中缀算术表达式，计算其结果。对输入的表达式，做如下假设： （1）只考虑+、-、*、/这四种运算符，中缀表达式中只有一种括号（）； （2）输入的中缀表达式中数字只有整数，没有小数； （3）假定输入表达式是合法的。 2测试用例 中缀表达式：（1）1+(2-3)*4+4/2 （2）a+(b-c)*d 3算法 建立两个栈，分别储存数字和运算符，在读取表达式的时候，凡是遇到数字，就将其压栈，压入stack1，当遇到运算符的时候进行判断，若栈为空，进行压栈，若
C语言 表达式计算
09-06
对从键盘输入一个表达式，进行运算，最后输出计算结果。 计算范围：包括一般的算术运算（加、减、乘、除、括号）和常用的函数运算（三角函数、自然指数函数、自然对数函数、绝对值函数、平方根函数）。
数据结构表达式计算（C语言）
05-10
数据结构程序（C语言）：输入一个算术表达式，由常量、变量、运算符和括号组成（规定：操作数只能为正整数，而操作符只能是＋、－、×、/这几个二元运算符，用“#”表示表达式结束），输出对算术表达式计算的结果。用栈实现表达式求值，分别为操作符栈和数栈实现，操作符的优先级预先设定（通过数组），
用堆栈实现中序表达式的计算过程
11-06
这是用堆栈实现中序表达式的计算过程，定义了+，-，*,/,%这几种基本用算，代码有助于理解堆栈的使用过程
中序表达式转前序后序
07-08
数据结构的中序表达式转前序，中序转后序，支持负数
中序转后序表达式的算术计算
04-23
这是一个介绍中序转后序表达式的算术计算，利用栈操作完成简单计算器的代码编写
c语言中缀表达式求值_前缀、中缀以及后缀表达式
weixin_39764494的博客
11-23 689
前言 最近开始刷题，真实地解决了大学时期“这黑窗口敲来敲去做数学题有卵用？”的困惑。有些东西之前学过，现在忘了，但是正是因为学过，所以再学一遍就变得效率很高(但是我还是不认可大学的学科教学顺序)。废话不多说，这篇博客只是一个笔记，希望之后有了更深的认识能够完善。前缀、中缀以及后缀表达式是什么？ 先聚合一下定义，以后万一要复习也好找XD前缀表达式 波兰表示法(Polish notation...
表达式求值【C语言实现】数据结构实验
热门推荐
lei20172017的博客
05-04 1万+
表达式求值【C语言实现】数据结构实验 实验内容 表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 实验要求 基本要求：以字符序列的形式从键盘输入语法正确的，不含变量的整型表达式。利用教科书表 3.1 给出的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例 3.1 演示在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。 实现提示 1 设置运算符栈和运算数栈辅助分析算符优先关系。 2 在读入表达式的字符序列的同时
python 表达式求值_用栈进行表达式求值
weixin_39954487的博客
12-03 1030
上一节课，我们介绍了栈，并且在习题里使用栈计算了后缀表达式(最后一道题，这道题一定要先完成。如果那道题做不出来，这节课的内容就更加难以理解)。我们今天继续看一下，如何使用栈完成标准的四则混合运算表达式求值。不同于后缀表达式，遇到一个运算符就可以直接从栈里取两个数进行运算。在标准的四则混合运算表达式中(或者我们称之为中缀表达式)，遇到一个操作符是不能直接计算的，因为计算的顺序要取决于后面的运算符。多...
数据结构--中缀表达式求值c语言代码实现
dagjj的博客
08-31 3182
/* 中缀表达式求值也就是 1、中缀表达式转后缀表达式 2、后缀表达式求值 合并 */ #include<stdlib.h> #include<stdio.h> #define Maxsize 10 typedef struct node{ char data[Maxsize]; int top; }Stack; bool Isempty(Stack &s){ if(s.top == -1){ return true; } return false;
利用中序和后序表达式建立二叉树C语言
05-25
下面是利用中序和后序表达式建立二叉树的C语言实现： ```c #include #include #include // 二叉树节点结构体定义 struct TreeNode { char data; // 节点数据 struct TreeNode *left; // 左子树指针 struct ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值