java 树形结构

树实体类

  public class Node {

    private int id;//结点id
    private int pid;//父结点id
    private String name;//结点值
    private List<Node> children = new ArrayList<>();//孩子结点列表
    private Node parent;
    private int level;

    public Node(int id,int pid,String name){
        this.id = id;
        this.pid = pid;
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public int getPid() {
        return pid;
    }

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

    public String getName() {
        return name;
    }

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

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

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

    public Node getParent() {
        return parent;
    }

    public void setParent(Node parent) {
        this.parent = parent;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public boolean isRoot() {
        return parent == null;
    }

    public boolean isLeaf() {
        return children.size() == 0;
    }
}

树结构排序工具类

public class TreeHelper {

    public static List<Node> getSortedNodes(List<Node> datas) {
        List<Node> result = new ArrayList<>();
        // 设置Node间父子关系
        List<Node> nodes = convertData2Node(datas);
        // 拿到根节点
        List<Node> rootNodes = getRootNodes(nodes);
        // 排序以及设置Node间关系
        for (Node node : rootNodes) {
            addNode(result, node, 0);
        }
        return result;
    }

    private static List<Node> convertData2Node(List<Node> nodes) {

        for (int i = 0; i < nodes.size(); i++) {
            Node n = nodes.get(i);
            for (int j = i + 1; j < nodes.size(); j++) {
                Node m = nodes.get(j);
                if (m.getPid() == n.getId()) {
                    n.getChildren().add(m);
                    m.setParent(n);
                } else if (m.getId() == n.getPid()) {
                    m.getChildren().add(n);
                    n.setParent(m);
                }
            }
        }
        return nodes;
    }

    private static List<Node> getRootNodes(List<Node> nodes) {
        List<Node> root = new ArrayList<>();
        for (Node node : nodes) {
            if (node.isRoot())
                root.add(node);
        }
        return root;
    }

    private static void addNode(List<Node> nodes, Node node, int currentLevel) {
        node.setLevel(currentLevel);
        nodes.add(node);
        if (node.isLeaf())
            return;
        for (int i = 0; i < node.getChildren().size(); i++) {
            addNode(nodes, node.getChildren().get(i), currentLevel + 1);
        }
    }
}

测试类

public class Test {

    public static void main(String[] args) {
        List<Node> nodes = new ArrayList<>();
        nodes.add(new Node(1, 0, "组织架构"));
        nodes.add(new Node(2, 1, "党委a"));
        nodes.add(new Node(3, 1, "党委b"));
        nodes.add(new Node(4, 2, "a支部1"));
        nodes.add(new Node(5, 2, "a支部2"));
        nodes.add(new Node(6, 2, "a支部3"));
        nodes.add(new Node(7, 3, "b支部1"));
        nodes.add(new Node(8, 3, "b支部2"));
        nodes.add(new Node(9, 4, "b支部3"));

        List<Node> list = TreeHelper.getSortedNodes(nodes);

        for (Node node : list) {
            for (int i = 0; i < node.getLevel(); i++)
                System.out.print("  ");
            System.out.println(node.getId() + " " + node.getName());
        }
    }
}

输出结果

1 组织架构
  2 党委a
    4 a支部1
      9 b支部3
    5 a支部2
    6 a支部3
  3 党委b
    7 b支部1
    8 b支部2