Tree 在Ada中建立二叉表达式树

我试图从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处找到操作符，这将是下一个节点。如果未找到运算符，则应使用数字创建叶节点。那里有一个循环，它解析输入并构建一个数字字符串来存储在节点中，因此多个数字应该可以工作。我一直在想，我在想，第一个和最后一个被送回Construction_ExpressionTree可能有些可疑

---

我只是在玩它，然后得到了一个测试用例。我将错误的信息发送回函数。

尽管不是Ada特有的，但您正在尝试构建一个，正如@NWS所指出的，“这本质上是一个递归问题”。由于您只需要

表达式

、

术语

和

因子

的结果，因此a将隐式构造树。实际上，正如所建议的，调用树就是解析树。另请参见概述的方法。

正如垃圾神提到的，这是您的答案，我相信他的链接提供了大量信息（通常是），但他可能忘记了关于这个问题最容易理解的文本之一：杰克·克伦肖的

---

除此之外，还有Niklaus Wirth的经典著作，其中有一章介绍递归（以及何时不使用递归）。

忘了提及-用于构建树的函数称为Construct_ExpressionTree，大约从代码的一半开始。1>我只是很快地看了一下，我怀疑你如何决定你的节点需要有多深。2> 这本质上是一个递归问题，您不使用递归有什么原因吗？3> 你检查“深度=1”，这是否意味着你只能得到2层树？4> 您只检查单个数字，这足够吗？