扁平多层数据转树结构

传入数组格式

list = [
[dep1, dep2, dep3, dep4],
[dep1, dep2, dep3, dep4],
[dep1, dep2, dep3, dep4],
……
]

创建节点类

public class Node{

    private Integer depth;
    private String name;
    private Integer parentId;
    private ArrayList<Node> children;
    
    public Node(Integer depth, Integer parentId, String name) {
        this.depth = depth;
        this.parentId = parentId;
        this.name = name;
    }
    
    public void add_children(Node node){
        if(this,children == null){
            this.children = new ArrayList<>();
        }
        this.children.add(node);
    }
    
    get\set方法
    ……
    @Override
    public String toString(){
        return "{" + 
                "\"depth\":" + depth +
                "\"name\":\"" + (name == null ? "" : name) + "\"" +
                "\"children\":" + (children = null ? "\"null\"" : children) + 
                "\"parentId\":" + parentId +
                "}";
    }
}

测试类

public class Convert{
    //不同层级名称
    HashMap<Integer, ArrayList<String>> dep_hash;
    //所有节点对象集合
    ArrayList<Node> nodes;
    
    //主方法
    public void treeMian(){
        dep_hash = new HashMap<>();
        nodes = new ArrayList<>();
        //创建根节点
        Node root = new Node(0, null, "root");)
        nodes.add(root);
        
        dep_hash.put(1, new ArrayList<>());
        dep_hash.put(2, new ArrayList<>());
        dep_hash.put(3, new ArrayList<>());
        dep_hash.put(4, new ArrayList<>());
        
        for(int i = 0; i< list.size; i++){
            //一级节点
            String data_1 = (String) list.get(i).get(0);
            //二级节点
            String data_2 = (String) list.get(i).get(1);
            //三级节点
            String data_3 = (String) list.get(i).get(2);
            //四级节点
            String data_4 = (String) list.get(i).get(3); 
            ……
            Integer node1_index = add_node(1,                0, data_1);
            Integer node2_index = add_node(2, node1_index, data_2);
            Integer node3_index = add_node(3, node2_index, data_3);
            Integer node4_index = add_node(4, node3_index, data_4);
            ……
        }
        //树结构，根节点是root
        System.out.println(root);
    }
    
    private Integer add_node(Integer depth, Integer parentId, String name){
        Integer _node_index = null;
        Node _node;
        
        if(!(dep_hash.get(depth).contains(name))){
            dep_hash.get(depth).add(name);
            _node = new Node(depth, parentId, name);
            nodes.add(_node);
            _node_index = nodes.size() - 1;
            nodes.get(parentId).add_children(_node);
        }
        
        if(_node_index == null){
            for(int i = 0; i < nodes.size(); i++0){
                if(nodes.get(i).getName().equals(name)){
                    _node_index = i;
                }
            }
        }
        return _node_index;
    }
}

Ruby版

# 传入数组格式 [
#  [dep1, dep2, dep3, dep4],
#  [dep1, dep2, dep3, dep4]
# ]
data = [] 
# 输入数据
dep_hash = {  1: [],  2: [],  3: [],  4: []} 
# 存各层级的数据, 1 2 3 4 分别对应1 2 3 4层级的数组
root = Node.create(0, '', 'root') 
# 创建根节点
nodes = [root] 
# 所有节点存放的数组，一开始只有根节点
class Node  
    def initialize depth, parentId, data               
        self.depth = depth    
        self.name = data    
        self.children = []    
        self.parentId = parentId   
        return self  
    end  
    
    def add_children node   
        self.children.push(node)    
        self.save  
    end
end
# 添加节点到树
# 返回以添加的节点对象和对应节点对象在nodes中的位置
def add_node depth, parent_id, data  
    _node_index = ''  
    _node  
# 如果该名称之前没有添加过节点或者该参数层级为第四级，就添加对应的Node节点对象  
# 并且将该名称加入对应深度的数组中，将该节点添加到nodes节点数组中  
# 并给对应的父节点添加子节点  
    unless dep_hash[depth].include?(data) || depth == 4    
        dep_hash[depth].push(data)    
        _node = Node.create(depth, parent_id, data)   
        nodes.push(_node)    
        _node_index = nodes.length - 1    
        nodes[parent_id].add_children(_node)  
    end  
    if _node_index.blank?    
        # 这里取到在nodes数组中的位置   
        _node_index = nodes.select{|n| n.name === data_1}  
    end  
    return _node_index
end
# 遍历数组，生成树
data.each do |item|  
    # 往所有节点数组中加入节点  
    data_1 = item[0][:data]  
    data_2 = item[1][:data]  
    data_3 = item[2][:data]  
    data_4 = item[3][:data]    
    # 添加节点到树  
    # 一层一层往里加  
    node1_index = add_node(1, 0, data1)  
    node2_index = add_node(2, node1_index, data_2)  
    node3_index = add_node(3, node2_index, data_3)  
    node4_index = add_node(4, node3_index, data_4)
end
puts nodes 
# 所有节点对象数组
puts root 
# 根节点