Java 向树结构递归添加子级（父级之前的子级）

我正在做一项实习作业，他们让我创建一个导航菜单，如下所示：

. Company
.... About Us
....... Team
.... Mission
. References
.... Client 1
.... Client 2

对我来说，整个任务的重点是找到一种方法，将这个输入转换成一个树结构，然后递归地打印出来。。。 输入为：

ID NAME PARENTID
1; Company; NULL;
2; About Us; 1;
3; Mission; 1;
4; Team; 2;
5; Client1; 7;
6; Client2; 7;
7; References; NULL;

如果这是一种先父后子的输入类型，那么任务将非常简单，但是我被卡住了，似乎无法理解其背后的算法。整个交易是在末尾添加引用，但客户端1和客户端2都是引用的子级

代码如下：

模型类：

// WITH SETTERS AND GETTERS
public class NavLink
{
    private String id;
    private String name;
    private String parentId;
    private String isHidden;
    private String linkUrl;
}

三重链接列表节点类：

public class TLLNode<NavLink>
{
    public NavLink element;
    public TLLNode<NavLink> parent, sibling, child;

    public TLLNode(NavLink elem)
    {
        this.element = elem;
        parent = sibling = child = null;
    }
}

公共类TLLNode
{
公共链接元素；
公共TLLNode父节点、兄弟节点、子节点；
公共TLLNode（导航链接elem）
{
该元素=元素；
父级=同级=子级=空；
}
}

树类：

public class Tree
{
    private TLLNode<NavLink> root;

    public Tree(NavLink element) { this.root = new TLLNode(element); }

    public TLLNode<NavLink> getRoot() { return this.root; }

    public void addChild(TLLNode<NavLink> node, NavLink element)
    {
        TLLNode<NavLink> insert =  new TLLNode<>(element);

       if (node.child == null)
            node.child = insert;

       else
       {
            if (node.child.element.getName().compareTo(insert.element.getName()) > 0)
                    insert.sibling = node.child;
            else
            {
                TLLNode<NavLink> tmp = node.child;
                while (tmp.sibling != null)
                {
                    if (tmp.sibling.element.getName().compareTo(insert.element.getName()) > 0)
                    {
                        insert.sibling = tmp.sibling;
                        break;
                    }
                    tmp = tmp.sibling;
                }
                tmp.sibling = insert;
            }
        }
        insert.parent = node;
    }

    public void printTree() { printTreeRecursive(this.root, 0); }

    private void printTreeRecursive(TLLNode<NavLink> node, int level)
    {
        if (node == null)
            return;

        for (int i=0; i < level-1; i++)
            System.out.print("...");

        if (node.element.getHidden().equalsIgnoreCase("False"))
            System.out.println("." + node.element.getName());

        TLLNode<NavLink> tmp = node.child;
        while (tmp != null)
        {
            printTreeRecursive(tmp, level+1);
            tmp = tmp.sibling;
        }
    }
}

公共类树
{
私有TLLNode根；
公共树（NavLink元素）{this.root=new-TLLNode（元素）；}
public TLLNode getRoot（）{返回this.root；}
public void addChild（TLLNode节点，NavLink元素）
{
TLLNode insert=新的TLLNode（元素）；
if（node.child==null）
node.child=插入；
其他的
{
if（node.child.element.getName（）.compareTo（insert.element.getName（））>0）
insert.sibling=node.child；
其他的
{
TLLNode tmp=node.child；
while（tmp.sibling！=null）
{
if（tmp.sibling.element.getName（）.compareTo（insert.element.getName（））>0）
{
insert.sibling=tmp.sibling；
打破
}
tmp=tmp.sibling；
}
tmp.sibling=插入；
}
}
insert.parent=节点；
}
public void printTree（）{printTreeRecursive（this.root，0）；}
私有void printTreeCursive（TLLNode节点，int级别）
{
if（node==null）
返回；
对于（int i=0；i<1级；i++）
系统输出打印（“…”）；
if（node.element.getHidden（）.equalsIgnoreCase（“False”））
System.out.println（“.”+node.element.getName（））；
TLLNode tmp=node.child；
while（tmp！=null）
{
打印树草书（tmp，级别+1）；
tmp=tmp.sibling；
}
}
}

最后是问题所在的主要类别：

public class Main
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        String[] parts;
        List<NavLink> list = new LinkedList<>();

        NavLink link = new NavLink("NULL", "/", "/", "True", "/" );
        Tree tree = new Tree(link);

        for (int i=0; i<n; i++)
        {
            parts = br.readLine().split(";");
            link = new NavLink(parts[0], parts[1], parts[2], parts[3], parts[4]);

            list.add(link);
        }

        /*TLLNode<NavLink> current;
        for (NavLink item : links)
        {
            current = new TLLNode<>(item);
            System.out.println(item);
            for (NavLink tmp : links.subList(1, links.size()))
            {
                if (tmp.getParentId().equalsIgnoreCase(current.element.getId()))
                    tree.addChild(current, tmp);
            }
        }*/

        addChildRecursive(tree, list, tree.getRoot());
        tree.printTree();
    }

    public static void addChildRecursive(Tree tree, List<NavLink> list, TLLNode<NavLink> current)
    {
        if (current == null)
            return;

        TLLNode<NavLink> insert;
        for (NavLink item : list)
        {
            insert = new TLLNode<>(item);
            if (insert.element.getParentId() == current.element.getId())
            {
                tree.addChild(current, insert.element);
                list.remove(insert.element);
                addChildRecursive(tree, list, current.child);
            }
        }
    }
}

公共类主
{
公共静态void main（字符串[]args）引发IOException
{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
int n=Integer.parseInt（br.readLine（））；
字符串[]部分；
列表=新建LinkedList（）；
NavLink link=新的NavLink（“空”）、“/”、“/”、“真”、“/”；
树=新树（链接）；
对于（inti=0；i首先，在java中，建议使用now equals（）函数而不是==运算符检查两个字符串是否相等。
现在，对于您的问题，您似乎只检查当前节点的子节点，因为可能有多个子节点，所以您不会全部检查它们。
我建议使用child列表或其他某种机制直接保存所有的子项，而不是通过“兄弟”指针