两次循环，生成多层树形结构

1、实体构造。

package com.ruoyi.web.suanfa;

import java.util.ArrayList;
import java.util.List;

public class TreeNode {
    /**
     * 节点Id
     */
    private Integer id;

    /**
     * 节点父ID
     */
    private Integer pid;

    /**
     * 节点名称
     */
    private String name;

    /**
     * 子节点
     */
    private List<TreeNode> children = new ArrayList<>();


    public TreeNode(Integer id, Integer pid, String name) {
        this.id = id;
        this.pid = pid;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<TreeNode> getChildren() {
        return children;
    }

    public void setChildren(List<TreeNode> children) {
        this.children = children;
    }
}

2、生成树形结构

package com.ruoyi.web.suanfa;

import org.apache.commons.collections.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @Author martin
 * @Description
 * @Date 2023/8/9
 **/
public class GenerateTree {
    public static List<TreeNode> generateTree(List<TreeNode> treeList) {
        if (CollectionUtils.isEmpty(treeList)) {
            return null;
        }
        Map<Integer, TreeNode> treeNodeMap = treeList.stream()
                .collect(Collectors.toMap(TreeNode::getId, Function.identity(), (o1, o2) -> o2));
        List<TreeNode> result = new ArrayList<>();
        for (TreeNode node : treeList) {
            if (node.getPid() == 0) {
                result.add(node);
                continue;
            }
            if (treeNodeMap.containsKey(node.getPid())) {
                treeNodeMap.get(node.getPid()).getChildren().add(node);
            } else {
                result.add(node);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List<TreeNode> tmp = new ArrayList<>();
        tmp.add(new TreeNode(1, 0, "一级"));
        tmp.add(new TreeNode(11, 0, "一级1"));
        tmp.add(new TreeNode(12, 0, "一级2"));

        tmp.add(new TreeNode(21, 1, "二级2"));
        tmp.add(new TreeNode(22, 1, "二级3"));
        tmp.add(new TreeNode(23, 1, "二级4"));

        tmp.add(new TreeNode(31, 11, "三级1"));
        tmp.add(new TreeNode(32, 11, "三级2"));
        tmp.add(new TreeNode(33, 11, "三级3"));

        tmp.add(new TreeNode(43, 21, "四级3"));
        tmp.add(new TreeNode(44, 21, "四级4"));
        tmp.add(new TreeNode(45, 22, "四级5"));

        tmp.add(new TreeNode(51, 43, "四级6"));
        tmp.add(new TreeNode(52, 43, "四级7"));
        tmp.add(new TreeNode(53, 44, "四级7"));
        List<TreeNode> list = generateTree(tmp);
        System.out.println(list.size());

    }
}

两次循环，比递归算法性能号太多了