Question

我正在尝试使用c＃实现n-ary类型的数据结构。树将具有根节点和子数组，子数组中的每个子节点也将具有子节点集。我想要做的是每当我们添加应该添加到叶节点中存在的所有子节点的子数组。我的代码是

      public void addChildren(Node root, Node[] children)
        {

             if (root.children == null)
            {
                root.children = children;

            }
            else
            {
                for (int i = 0; i < root.children.Length; i++)
                {

                    addChildren(root.children[i], children);
                }
            }

        }

主程序

     Dictionary<String, String[]> measurelist = new Dictionary<string, string[]>();
        String[] values = { "y", "n" };
        measurelist.Add("m1", values);
        measurelist.Add("m2", values);
        measurelist.Add("m3", values);           
        foreach (KeyValuePair<String, String[]> entry in measurelist)
        {
            Node[] children = new Node[entry.Value.Length];
           for(int i = 0; i < entry.Value.Length ;i ++)
            {
                Node child = new Node(entry.Key+":"+entry.Value[i]);
                children[i] = child;
            }

            clustertree.addChildren(clustertree.root, children);               
        }

但是此代码会导致无限递归调用。我试过但无法弄清楚出了什么问题？请帮我弄清楚我做错了什么。 I have described the problem in the image

解决方案：   在你的帮助下，我找到了解决这个问题的方法。如果我解释根本原因，我认为这对可能面临同样问题的其他人有帮助。   当我传递子节点数组时问题的主要原因是它作为引用而不是值传递。我已经更改了我的代码，以确保相同的子数组引用不会传递给下一个递归调用。

以下是我更正后的代码：

 public void addChildren(Node root, Node[] children)
        {

             if (root.children == null)
            {

                root.children = children;

            }
            else
            {
                for (int i = 0; i < root.children.Length; i++)
                {                       
                    Node[] children1 = new Node[children.Length];
          //I am creating a new array and nodes and passing the newly created array to                                       the next recursive call
                    for (int j = 0; j < children.Length; j++)
                    {
                        Node node = new Node(children[j].key);                           
                        node.children = children[j].children;
                        children1[j] = node;
                    }
                    addChildren(root.children[i], children1);
                }
            }

        }

再次感谢：）

Answer 1

您应该将内部node[]变为list<node>而不是数组。

然后使用此代码

      public void addChildren(Node root, Node[] children)
        {

            if (root.children == null)
            {
                root.children = new List<Node>();

            }

            root.children.AddRange(children);

        }

Answer 2

您没有像图中所示那样创建树，而是执行以下操作：

       R
      / \
     /   \
    a1   a2 (children of this are actually b1 and b2)
   / \   
  /   \
 b1   b2

当您将b1, b2添加为a2的孩子时，您引用的是已添加到b1 and b2的同一a1。

在下一次迭代中，当您添加c1 and c2时，根据您的算法，您首先通过c1 and c2将b1 and b2引用到a1，但您的功能并未停在这里，它会去这一次通过b1 and b2再次发送到a2，但由于c1 and c2已被添加为b1 and b2的子项，因此算法会混淆并进入永久循环。

解决这个问题：

查找最后一级树，但直到最后一级只使用一个子项的递归路径。

public boolean addChildren(Node root, Node[] children)
{

    if (root.children == null)
    {
        root.children = children;
        return true;
    }
    else
    {
        for (int i = 0; i < root.children.Length; i++)
        {
            /* if it returns true then it was last level 
                   else break */
            if(!addChildren(root.children[i], children)) 
            {
                /* this is non-last level break */
                break;
            }
        }
    }
    return false;
}

在n tree实现中需要帮助

2 个答案: