Java-List数据转树结构

List数据转树结构

测试数据：

//节点类
public class TreeNode {
    private String id;
    private String name;
    private String pid;
    private List<TreeNode> children;
}

//测试数据
TreeNode node1 = new TreeNode("1", "根节点", "0");
TreeNode node2 = new TreeNode("2", "2层节点01", "1");
TreeNode node3 = new TreeNode("3", "2层节点02", "1");
TreeNode node4 = new TreeNode("4", "3层节点01", "2");
TreeNode node5 = new TreeNode("5", "3层节点02", "2");
TreeNode node6 = new TreeNode("6", "3层节点03", "3");
TreeNode node7 = new TreeNode("7", "3层节点04", "3");

方法1：stream流递归

List<TreeNode> treeNodeList = nodeList.stream().filter(node -> {
    return node.getPid().equals("0");
}).peek(node -> {
    node.setChildren(getChildNode(node.getId(), nodeList));
}).collect(Collectors.toList());


private static List<TreeNode> getChildNode(String id, List<TreeNode> nodeList) {
    List<TreeNode> treeNodes = nodeList.stream().filter(node -> {
        return node.getPid().equals(id);
    }).peek(node -> {
        node.setChildren(getChildNode(node.getId(), nodeList));
    }).collect(Collectors.toList());
    return treeNodes;
}

方法二：非递归实现

public class TreeNode {
    private int id;
    private String name;
    private List<TreeNode> children;

    public TreeNode(int id, String name) {
        this.id = id;
        this.name = name;
        this.children = new ArrayList<>();
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

    public void addChild(TreeNode child) {
        children.add(child);
    }

    public static TreeNode convertToTree(List<TreeNode> nodes) {
        Map<Integer, TreeNode> nodeMap = new HashMap<>();
        TreeNode root = null;
        
        // 构建节点映射表，并找到根节点
        for (TreeNode node : nodes) {
            nodeMap.put(node.getId(), node);
            if (node.getId() == 0) {
                root = node;
            }
        }

        // 将非根节点添加到对应父节点的children中
        for (TreeNode node : nodes) {
            if (node.getId() != 0) {
                TreeNode parent = nodeMap.get(node.getId() / 2);
                if (parent != null) {
                    parent.addChild(node);
                }
            }
        }

        return root;
    }
}

ArrayList<TreeNode> treeList = new ArrayList<>();//树
HashMap<String, TreeNode> map = new HashMap<>();

for (TreeNode treeNode : nodeList) {
    if (treeNode.getPid().equals("0")) {
        treeList.add(treeNode);
    }
    map.put(treeNode.getId(), treeNode);
}

for (TreeNode treeNode : nodeList) {
    TreeNode pNode = map.get(treeNode.getPid());
    if (pNode != null) {
        List<TreeNode> children = pNode.getChildren();
        if (children == null){
            pNode.setChildren(new ArrayList<>());
        }
        pNode.getChildren().add(treeNode);
    }
}

//基于队列的方式
public class TreeNode {
    private int id;
    private String name;
    private List<TreeNode> children;

    public TreeNode(int id, String name) {
        this.id = id;
        this.name = name;
        this.children = new ArrayList<>();
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

    public void addChild(TreeNode child) {
        children.add(child);
    }

    public static TreeNode convertToTree(List<TreeNode> nodes) {
        Map<Integer, TreeNode> nodeMap = new HashMap<>();
        TreeNode root = null;

        // 构建节点映射表，并找到根节点
        for (TreeNode node : nodes) {
            nodeMap.put(node.getId(), node);
            if (node.getId() == 0) {
                root = node;
            }
        }

        // 基于队列的实现方式
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode parent = queue.poll();
            for (TreeNode node : nodes) {
                if (node.getId() / 2 == parent.getId()) {
                    TreeNode child = nodeMap.get(node.getId());
                    parent.addChild(child);
                    queue.offer(child);
                }
            }
        }

        return root;
    }
}

遍历树形结构

//非递归的方式/深度优先遍历
public class TreeNode {
    private int val;
    private List<TreeNode> children;
    
    public TreeNode(int val) {
        this.val = val;
        this.children = new ArrayList<TreeNode>();
    }
    
    // Getters and setters for the class fields
    
    public void traverse(TreeNode root) {
        if (root == null) {
            return;
        }
        
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        
        while(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            
            // Do something with the current node
            System.out.println(node.getVal());
            
            List<TreeNode> children = node.getChildren();
            if(children != null && children.size() > 0) {
                for(int i=children.size()-1; i>=0; i--) {
                    stack.push(children.get(i));
                }
            }
        }
    }
}

//层序遍历/广度优先遍历
public class TreeNode {
    private int val;
    private List<TreeNode> children;
    
    public TreeNode(int val) {
        this.val = val;
        this.children = new ArrayList<TreeNode>();
    }
    
    // Getters and setters for the class fields
    
    public void traverse(TreeNode root) {
        if (root == null) {
            return;
        }
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        
        while(!queue.isEmpty()) {
            int levelSize = queue.size();
            for(int i=0; i<levelSize; i++) {
                TreeNode node = queue.poll();
                
                // Do something with the current node
                System.out.println(node.getVal());
                
                List<TreeNode> children = node.getChildren();
                if(children != null && children.size() > 0) {
                    for(TreeNode child : children) {
                        queue.offer(child);
                    }
                }
            }
        }
    }
}

//递归方式遍历多叉树
public class TreeNode {
    private int val;
    private List<TreeNode> children;
    
    public TreeNode(int val) {
        this.val = val;
        this.children = new ArrayList<TreeNode>();
    }
    
    // Getters and setters for the class fields
    
    public void traverse(TreeNode node) {
        if (node == null) {
            return;
        }
        
        // Do something with the current node
        System.out.println(node.getVal());
        
        List<TreeNode> children = node.getChildren();
        if(children != null && children.size() > 0) {
            for(TreeNode child : children) {
                traverse(child);
            }
        }
    }
}