使用堆栈和二叉树c构建表达式树

Question

我给了一个算术公式，其中包含运算符+，-，*，/和括号（这可能会或可能不会更改运算符的自然优先级）。 例如：a / b + f –（c + d）* e – a * c。 并要求我使用一个堆栈（实现为链接列表）以跟踪操作数和运算符：以下是我的程序应如何工作的示例：

• 读一个，压入操作数栈
• 读/，压入运算符堆栈
• 读b，压入操作数堆栈
• 读+：的优先级低于/，因此：
  • 从操作数堆栈中弹出2个操作数（a和b）
  • 从操作员弹出/弹出
  • 创建子树并压入操作数堆栈
  • 操作符堆栈为空，因此在其上按+
• 读取f，压入操作数堆栈
• 读-：优先级与+相同，因此：
  • 从操作数堆栈中弹出2个操作数
  • 弹出运算符+来自运算符堆栈
  • 创建一个以运算符+为根，两个操作数为左，右子代的树
  • 将创建的树的根推回操作数堆栈
  • 操作员堆栈为空，因此在其上推入

我难以理解的问题是如何区分操作数的优先级 ！

这是我编写的代码的不完整版本：

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>

typedef struct btnode Btree;
typedef struct node s_Node;

struct btnode {
    char info; 
    Btree *left; 
    Btree *right;
};


struct node {
    char element;
    s_Node*next;
}; 

typedef struct{
    s_Node *top_stack;
} stack_t; 

int IsOperator(char c);

main () {
    FILE* fp;
    stack_t operands;
    stack_t operators;
    char c;
    operands=NewStack();
    operators=NewStack();
    fp= fopen ("Myfile.txt", "r");
    if (fp== NULL)
        printf ("   FILE COULD NOT BE OPENED");
    else
    {
        c=getc(fp);
        while (!feof (fp))
        {
            if ( c== ' ');
            else 
            {
                printf ("Here is your character: %c\n", c);
                if (IsOperator (c))
                    Push (c, &operands);
                else if ( isalpha (c))


            }
        c=getc(fp);
        }
    }
}

int IsOperator(char c)
{   
    switch(c)
    {
        case '+':
        case '-':
        case '/':
        case '*':
        return 1;
        default:
        return 0;
    }
} 

stack_t NewStack()
{
    stack_t *n_stack;
    n_stack=(stack_t*)malloc(sizeof(stack_t));
    n_stack->top_stack=NULL;
    return (*n_stack);  
}

int Push(char e, stack_t *q)
{       
    s_Node *nn;
    nn= (s_Node*)malloc(sizeof(s_Node));

    if(Full(*q))
    {
        printf("\n\t Stack is Full !! \n\n");
        return 0;   // return 0 if enstack NOT successful
    }
    else 
    { 
        nn->element=e; // Storing the elemnt read inside the the new node
        nn->next=q->top_stack; // Pointing the new node to the top of the stack
        q->top_stack=nn; // Changing the top of the stack
        return 1;
    }
}

先感谢您！

Answer 1

对于您使用的算法，操作数没有优先级。 但是在自底向上的移位减少解析器中，它确实具有优先级，正如@WhozCraig在下面的这篇文章的评论中所说。

操作数总是被压入操作数堆栈中，并会弹出2并由一个运算符进行计算，然后再次作为单个操作数被压入操作数堆栈。

对于您的公式：a / b + f –（c + d）* e – a * c

• 一种
• push送到操作数堆栈
• 操作数

• 操作员 ：

• /

• push送到操作员堆栈
• 操作数

• 运算子 ：/

• b

• push送到操作数堆栈
• 操作数 ：ab

• 运算子 ：/

• +

• + <= / -> pop /，a ＆ b-> a / b->推送到操作数堆栈
• 推+到运算符堆栈
• 操作数 ：（a / b）

• 运算子 ：+

• F

• 推送到操作数堆栈
• 操作数 ：（a / b）f

• 运算子 ：+

• -

• - <= + -> pop +，（a / b） ＆ f->（a / b） + f->压入操作数堆栈
• 操作数 ：（（a / b）+ f）

• 操作员 ：-

• （

• 推送到操作员堆栈
• 操作数 ：（（a / b）+ f）

• 运算子：-（

• C

• 推送到操作数堆栈
• 操作数 ：（（a / b）+ f）c

• 运算子：-（

• +

• 推送到操作员堆栈
• 操作数 ：（（a / b）+ f）c

• 运算子 ：-（+

• d

• 推送到操作数堆栈
• 操作数 ：（（a / b）+ f）cd

• 运算子 ：-（+

• ）

• 直到'（'弹出，一一弹出堆栈中的所有运算符，并使用2个操作数进行计算
• -> pop +，c ＆ d-> c + d->推送到操作数堆栈
• 操作数 ：（（a / b）+ f）（c + d）
• 运算子：-（
• ->弹出（，停止弹出运算符堆栈
• 操作数 ：（（a / b）+ f）（c + d）

• 操作员 ：-

• *

• * > -推送到操作员堆栈
• 操作数 ：（（a / b）+ f）（c + d）

• 运算子 ：-*

• Ë

• * > -推送到操作数堆栈
• 操作数 ：（（a / b）+ f）（c + d）e

• 运算子 ：-*

• -

• - <= * pop *，（c + d） ＆ e->（c + d）* e->压入操作数堆栈
• 操作数 ：（（a / b）+ f）（（c + d）* e）
• 操作员 ：-
• - <= - pop-，（（（a / b）+ f） ＆ （（c + d）* e）->（（a / b）+ f） - （（c + d）* e）->推操作数栈
• 推送到操作员堆栈
• 操作数 ：（（（（a / b）+ f）-（（c + d）* e））

• 操作员 ：-

• 一种

• 推送到操作数堆栈
• 操作数 ：（（（（a / b）+ f）-（（c + d）* e））a

• 操作员 ：-

• *

• * > -推送到操作员堆栈
• 操作数 ：（（（（a / b）+ f）-（（c + d）* e））a

• 运算子 ：-*

• C

• 推送到操作数堆栈
• 操作数 ：（（（（a / b）+ f）-（（c + d）* e））ac

• 运算子 ：-*

• 行结束

• 逐一弹出堆栈中的所有运算符
• pop *，a＆c->（a * c）->推送到操作数堆栈
• 操作数 ：（（（（a / b）+ f）-（（c + d）* e））（a * c）
• 操作员 ：-
• 弹出-，（（（（a / b）+ f）-（（c + d）* e）） ＆ （a * c）->（（（（a / b）+ f）-（（c + d）* e）） - （a * c）->推送到操作数堆栈
• 操作数 ：（（（（（a / b）+ f）-（（c + d）* e））-（a * c））
• 操作员 ：

结果：（（（（（a / b）+ f）-（（c + d）* e））-（a * c））