Question

我正在尝试在Ada中使用完全带括号的中缀表示法构建表达式树。我正在递归地构建树。每个节点都有一个数据字段，以及一个指向左右子节点的指针。以下是我汇总实施的内容。

WITH Ada.Integer_Text_IO, Ada.Text_IO;
USE Ada.Text_IO;

PACKAGE BODY Tree_Expression IS
   FUNCTION To_String (
         Input : Tree_String)
     RETURN String IS
      Last : Natural := 0;
   BEGIN
      FOR I IN Input'RANGE LOOP
         IF Input(I) /= ' ' THEN
            Last := Last + 1;
         END IF;
      END LOOP;
      RETURN Input(Input'First .. Last);
   END To_String;

   FUNCTION To_Number (
         Input : String)
     RETURN Float IS
      Output : Integer;
      First  : Integer  := - 1;
      Last   : Positive;
   BEGIN
      FOR I IN Input'RANGE LOOP
         IF Input(I) IN '0'..'9' THEN
            First := I;
            EXIT;
         END IF;
      END LOOP;
      IF First = -1 THEN
         RAISE Number_Error;
      END IF;
      IF First = Input'First THEN
         Ada.Integer_Text_IO.Get(
            From => Input,
            Item => Output,
            Last => Last);
         RETURN Float(Output);
      ELSE
         Ada.Integer_Text_IO.Get(Input(First .. Input'Last), Output, Last);
         RETURN Float(Output);
      END IF;
   END To_Number;

   FUNCTION To_Char (
         Input : String)
     RETURN Character IS
   BEGIN
      FOR I IN Input'RANGE LOOP
         IF Input(I) = '*' OR Input(I) = '/' OR Input(I) = '+' OR Input(I) = '-' OR Input(I) = '^' THEN
            RETURN Input(I);
         END IF;
      END LOOP;
      RAISE Operator_Error;
   END To_Char;

   FUNCTION Construct_ExpressionTree (
         Expression_String : String;
         First,
         Last              : Natural)
     RETURN Expression_Node_Ptr IS
      Depth           : Natural     := 0;
      Pos             : Natural     := 0;
      Operator        : Character   := ' ';
      Number_String   : Tree_String;
      Operator_String : Tree_String;
      Build_Num_Str   : Natural     := Number_String'First;
   BEGIN
      FOR I IN First..Last LOOP
         CASE(Expression_String(I)) IS
            WHEN '(' =>
               Depth := Depth + 1;
            WHEN ')' =>
               Depth := Depth - 1;
            WHEN '+'|'-'|'*'|'/'|'^' =>
               IF Depth = 1 THEN
                  Pos := I;
                  Operator := Expression_String(I);
                  EXIT;
               END IF;
            WHEN OTHERS =>
               NULL;
         END CASE;
      END LOOP;
      IF Operator = '+' OR Operator = '-' OR Operator = '*' OR Operator = '/' OR Operator = '^' THEN
         Operator_String(Operator_String'First) := Operator;
         FOR I IN Operator_String'RANGE LOOP
            IF I > Operator_String'First THEN
               Operator_String(I) := ' ';
            END IF;
         END LOOP;
         RETURN Binary_Expression_Tree.Create_Node(Operator_String, Construct_ExpressionTree(Expression_String, 
            Expression_String'First+1, Pos-1), Construct_ExpressionTree(Expression_String, Pos+1, Expression_String'Last-1));
      ELSE
         FOR I IN First..Last LOOP
            IF Expression_String(I) IN '0'..'9' THEN
               Number_String(Build_Num_Str) := Expression_String(I);
               Build_Num_Str := Build_Num_Str +1;
            ELSIF Expression_String(I) = ')' THEN
               EXIT;
            ELSE
               NULL;
            END IF;
         END LOOP;
         IF Build_Num_Str = Number_String'First THEN
            RAISE Number_Error;
         END IF;
         FOR I IN Build_Num_Str..Number_String'Last LOOP
            Number_String(I) := ' ';
         END LOOP;
         RETURN Binary_Expression_Tree.Create_Node(Number_String, NULL, NULL);
      END IF;

   END Construct_ExpressionTree;

   FUNCTION Evaluate_Expression (
         Node : Expression_Node_Ptr)
     RETURN Float IS
      FUNCTION Eval (
            Node : Expression_Node_Ptr)
        RETURN Float IS
         Data     : Tree_String := Binary_Expression_Tree.Get_Data (Node);
         Operator : Character;
      BEGIN
         Operator := To_Char(Data);
         CASE Operator IS
            WHEN '+' =>
               RETURN Eval(Binary_Expression_Tree.Get_Left_Child(Node)) + Eval(Binary_Expression_Tree.Get_Right_Child(Node));
            WHEN '-' =>
               RETURN Eval(Binary_Expression_Tree.Get_Left_Child(Node)) - Eval(Binary_Expression_Tree.Get_Right_Child(Node));
            WHEN '*' =>
               RETURN Eval(Binary_Expression_Tree.Get_Left_Child(Node)) * Eval(Binary_Expression_Tree.Get_Right_Child(Node));
            WHEN '/' =>
               RETURN Eval(Binary_Expression_Tree.Get_Left_Child(Node)) / Eval(Binary_Expression_Tree.Get_Right_Child(Node));
            WHEN '^' =>
               RETURN Eval(Binary_Expression_Tree.Get_Left_Child(Node)) ** Natural(Eval(Binary_Expression_Tree.Get_Right_Child(Node)));
            WHEN OTHERS =>
               RAISE Expression_Error;
         END CASE;
      EXCEPTION
         WHEN Operator_Error =>
            RETURN To_Number(Data);
      END Eval;
   BEGIN
      RETURN Eval (Node);
   END Evaluate_Expression;

   FUNCTION Infix_Notation (
         Node : Expression_Node_Ptr)
     RETURN String IS
   BEGIN
      RETURN Binary_Expression_Tree.Inorder_Traversal(Node);

   END Infix_Notation;

   FUNCTION Prefix_Notation (
         Node : Expression_Node_Ptr)
     RETURN String IS
   BEGIN
      RETURN Binary_Expression_Tree.Preorder_Traversal(Node);
   END Prefix_Notation;

   FUNCTION Postfix_Notation (
         Node : Expression_Node_Ptr)
     RETURN String IS
   BEGIN
      RETURN Binary_Expression_Tree.Postorder_Traversal(Node);
   END Postfix_Notation;

END Tree_Expression;

我的问题是当我输入一个表达式时，例如，（（5 + 6）*（1-3）），树的构建不正确。从该表达式构建的树的顺序遍历的输出是5 + 6 * 5 + 6-3而不是5 + 6 * 1-3。基本上，根的右子（1）的左子项没有被添加到树中，并且（5 + 6）被再次添加到其位置。

Create_Node是构造函数中调用的函数，如下所示：

FUNCTION Create_Node (
         Data        : Item_Type;
         Left_Child,
         Right_Child : Node_Ptr)
     RETURN Node_Ptr IS
   BEGIN
      RETURN NEW Node_Type'(Data, Left_Child, Right_Child);
   END Create_Node;

这是用于家庭作业 - 我只是在寻找关于一般出了什么问题的指针，以及我的代码部分，它们是有意义的。提前谢谢。

反馈后编辑：这是我的思考过程，希望它跟踪：
- 首先在depth = 1处找到运算符，该运算符将是树的根节点 - 一旦我有了这个，我创建一个节点，左边的所有内容都作为左子节点发送回构造函数，右边的所有内容作为右子节点发回。据我了解，这是构建树的递归方法 - 每次调用该函数时，它应该找到深度为1的运算符，该运算符将是下一个节点。如果找不到运算符，则应该使叶子节点具有数字。那里有一个循环来解析输入并构建一个数字字符串来存储在节点中，因此多个数字应该有效。我一直在考虑这个问题，而且我认为将First和Last发送回Construct_ExpressionTree可能会出现问题。

我只是玩它并得到一个测试用例。我把错误的信息发回了函数。

Answer 1

虽然不是特定于Ada，但您正在尝试构建abstract syntax tree，这是“基本上是一个递归问题”，如@NWS所述。由于您只需要expression，term和factor的制作，recursive descent parser会隐式构建树。实际上，调用树是解析树，如建议的here。另见概述here的方法。

Answer 2

正如Trashgod提到的递归得体是你的答案，我确信他的链接非常有用（他们通常都是这样），但他忘了这个问题最容易接近的文本之一：Jack Crenshaw的Let's Build a Compiler。 / p>

除此之外，还有Niklaus Wirth Algorithms + Data Structures = Programs的经典着作，其中有一章关于递归（以及何时不使用它）。

在Ada中构建二进制表达式树

2 个答案: