树节点按父子关系排序

本文简单总结一个列表排序方法，例如组织场景，所有除根节点外，所有组织节点都有其父节点，当我们拿到的组织列表是一个无序的，即父、子节点散乱存放，同时需要得到一个所有父节点都存放在子节点前的列表，可以考虑使用下面的方法。

首先构造一个树结构：

public class OrgTreeNode {
 
    /**
     * 树的每个结点包含四个属性，分别是该结点的ID（组织ID）；该结点的父ID（组织的上级组织结点）；组织名称；子结点列表（该组织下一级的组织）
     */
 
    private String orgIndexCode;
 
    private String orgName;
 
    private String orgParentIndexCode;
 
    private List<OrgTreeNode> children;
}

然后我们要考虑到，现在已有的是一个组织列表List<OrgSaveReqV1Vo>，为了使批量插入的组织满足先插父结点，再插子结点的效果，我们需要将这个list中的组织排序；

想要得到组织按层级排序后的列表，需要经过以下几个步骤：

1、将列表中的组织去出，转化为若干个结点类型OrgTreeNode ；

2、将OrgTreeNode 组合起来，构造若干棵树，得到一个树的列表；

注：这里提到的若干棵树是因为，除第一次添加以外，每次添加组织都不一定是围绕一个结点展开，大多时候可能会在多个同级或不同级的组织结点下添加组织，因此，将添加列表中的组织构造以后得到的不仅仅是一棵树；

3、遍历得到的树，对于每一棵树按层次遍历它的结点，并将结点放入新的列表中；

4、最后得到排序后的列表；

@Override
public void batchSaveOrg2Irds(List<OrgSaveReqV1Vo> list){
 
    if(ObjectUtils.isEmpty(list)){
    return;
    }
    //遍历组织添加列表，按照
    //<parentIndexCode, List<>>
    //将列表中的数据构造为多个“枝干”，即以父id为key，组织对象为value；
    Map<String, OrgTreeNodesWithFlag> treeMap = new HashMap<>(16);
    list.forEach(item->{
        //如果父结点已经存在于map中，则将该结点作为子结点插入
        if(treeMap.containsKey(item.getParentIndexCode())){
            treeMap.get(item.getParentIndexCode()).getNodes().add(parseNode(item));
        }else{
            //如果不存在，则新建一个结点；
            List<OrgTreeNode> itemList = new ArrayList<>();
            itemList.add(parseNode(item));
            OrgTreeNodesWithFlag orgTreeNodesWithFlag = new OrgTreeNodesWithFlag();
            orgTreeNodesWithFlag.setNodes(itemList);
            treeMap.put(item.getParentIndexCode(), orgTreeNodesWithFlag);
        }
    });
 
    //经过第一步操作后，我们得到一个map，里面存放了若干结点，它们是若干颗只有二级的树结构；
    //这种树结构之间并不是相互独立的，他们之间有可能存在一种情况：A的子结点是B的父结点；
    //遍历map，将有关联的“枝干”拼接成若干棵树（这些树之间不存在父子关系）；
    for(Iterator<Map.Entry<String, OrgTreeNodesWithFlag>> iterator = treeMap.entrySet().iterator();iterator.hasNext();){
        OrgTreeNodesWithFlag orgTreeNodesWithFlag = iterator.next().getValue();
        if(!orgTreeNodesWithFlag.isDelete()){
            List<OrgTreeNode> orgTreeNodeList = orgTreeNodesWithFlag.getNodes();
            if(ObjectUtils.isNotEmpty(orgTreeNodeList)) {
                orgTreeNodeList.forEach(item -> {
                    getChildren(item, treeMap);
                });
            }
        }
    }
 
    //经过上面的操作后，我们可以得到若干颗没有父子关联的树；  
    //遍历所有没有被标记为删除的树，每拿到一棵树就去遍历它的节点，每遍历一次节点就把这个节点放到同步列表中，直到把一颗树的节点全部依层次放入同步列表；
    //最终将树重新转化为一个列表，这个组织列表和最开始的不同，他是有序的，即所有应该先插入的组织排在前面；
    List<OrgSaveReqV1Vo> reqV1Vos = new ArrayList<>();
    for(Iterator<Map.Entry<String, OrgTreeNodesWithFlag>> iterator = treeMap.entrySet().iterator();iterator.hasNext();){
        OrgTreeNodesWithFlag orgTreeNodesWithFlag = iterator.next().getValue();
        if(!orgTreeNodesWithFlag.isDelete() && ObjectUtils.isNotEmpty(orgTreeNodesWithFlag.getNodes())){
            //放当前层级
            Queue<OrgTreeNode> queue = new LinkedList<>();
            for (OrgTreeNode node : orgTreeNodesWithFlag.getNodes()) {
                queue.offer(node);
                reqV1Vos.add(parseSaveReqV1Vo(node));
            }
            generateAddList(reqV1Vos, queue);
        }
    }
    //这里的reqV1Vos就是最后我们需要的排序后的组织列表
     
}

这里提到一个OrgTreeNodesWithFlag 类；

@Data
public class OrgTreeNodesWithFlag {
    //结点列表，可以理解为一棵树
    private List<OrgTreeNode> nodes;
    //表示这棵树是否存在的标识
    private boolean delete;
}

两个类型转化方法：

//完成将组织类型，转化为组织节点类型
private OrgTreeNode parseNode(OrgSaveReqV1Vo orgSaveReqV1Vo){
    OrgTreeNode orgTreeNode = new OrgTreeNode();
    orgTreeNode.setOrgIndexCode(orgSaveReqV1Vo.getOrgIndexCode());
    orgTreeNode.setOrgName(orgSaveReqV1Vo.getOrgName());
    orgTreeNode.setOrgParentIndexCode(orgSaveReqV1Vo.getParentIndexCode());
    return orgTreeNode;
}
//将组织节点类型转化为，组织类型
private OrgSaveReqV1Vo parseSaveReqV1Vo(OrgTreeNode orgTreeNode){
    OrgSaveReqV1Vo orgSaveReqV1Vo = new OrgSaveReqV1Vo();
    orgSaveReqV1Vo.setOrgIndexCode(orgTreeNode.getOrgIndexCode());
    orgSaveReqV1Vo.setOrgName(orgTreeNode.getOrgName());
    orgSaveReqV1Vo.setParentIndexCode(orgTreeNode.getOrgParentIndexCode());
    return orgSaveReqV1Vo;
}

这个方法通过不断弹出队列中的元素，实现对单棵树组织的遍历

private void generateAddList(List<OrgSaveReqV1Vo> reqV1Vos, Queue<OrgTreeNode> queue){
    while(!queue.isEmpty()){
        //只要队列不为空，就把队列中的第一个结点弹出，并删除
        OrgTreeNode orgTreeNode = queue.poll();
        if(ObjectUtils.isNotEmpty(orgTreeNode.getChildren())){
            //同时将这个结点的子结点放入队列
            for (OrgTreeNode child : orgTreeNode.getChildren()) {
                reqV1Vos.add(parseSaveReqV1Vo(child));
                queue.offer(child);
            }
        }
    }
}

这个方法通过递归，不断遍历树的过程中，寻找该结点在map里的子结点

private void getChildren(OrgTreeNode root, Map<String, OrgTreeNodesWithFlag> treeMap){
    //如果当前结点对应的ID，在map中存在，则证明有一个树结构应该归到当前节点的子结点中
    if(treeMap.containsKey(root.getOrgIndexCode()) && !treeMap.get(root.getOrgIndexCode()).isDelete()){
        List<OrgTreeNode> children = treeMap.get(root.getOrgIndexCode()).getNodes();
        root.setChildren(children);
        if(ObjectUtils.isNotEmpty(children)) {
            children.forEach(item -> {
                //递归遍历子结点
                getChildren(item, treeMap);
            });
        }
        //每当找到一个子结点时，就把这个子结点归入已有的树结构，并在map中删除该结点；
        treeMap.get(root.getOrgIndexCode()).setDelete(true);
    }
}