欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

递归遍历出所有父子级的层级关系【包含跨级】

程序员文章站 2023-12-03 10:53:58
问题需要递归遍历出所有父子级的层级关系【包含跨级】如图:需要找出各个有父子级关联之间的层级关系,例如 节点0 和 节点1,节点0 和 节点3,节点 1 和 节点5 之间的关系(节点2 和 节点4不算)解题思路:1:拿到本节点的子节点2:把子节点当主节点,获取主节点与父节点的层级关系3:判断主节点的父节点是否为顶层节点,如果不是,则获取到父节点并递归取父节点的父节点,获取主节点与【父节点的父节点】的层级关系4:依次判断,递归具体案例代码:import lombok.Data;impo...

问题
需要递归遍历出所有父子级的层级关系【包含跨级】
如图:需要找出各个有父子级关联之间的层级关系,例如 节点0 和 节点1,节点0 和 节点3,节点 1 和 节点5 之间的关系(节点2 和 节点4不算)
递归遍历出所有父子级的层级关系【包含跨级】
解题思路:
1:拿到本节点的子节点
2:把子节点当主节点,获取主节点与父节点的层级关系
3:判断主节点的父节点是否为顶层节点,如果不是,则获取到父节点并递归取父节点的父节点,获取主节点与【父节点的父节点】的层级关系
4:依次判断,递归

具体案例代码:

import lombok.Data;

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


@Data
class MyNode{
    private int id;
    private int pid;
    private MyNode pNode; // 存 父节点
}

public class TreeDemo {

    public static void main(String[] args) {
        List<MyNode> nodeList = new ArrayList<>();

        MyNode node = new MyNode();
        node.setId(0);
        node.setPid(-1);
        nodeList.add(node);

        MyNode node1 = new MyNode();
        node1.setId(1);
        node1.setPid(0);
        nodeList.add(node1);

        MyNode node2 = new MyNode();
        node2.setId(2);
        node2.setPid(0);
        nodeList.add(node2);

        MyNode node3 = new MyNode();
        node3.setId(3);
        node3.setPid(1);
        nodeList.add(node3);

        MyNode node4 = new MyNode();
        node4.setId(4);
        node4.setPid(1);
        nodeList.add(node4);

        MyNode node5 = new MyNode();
        node5.setId(5);
        node5.setPid(3);
        nodeList.add(node5);

        // 给出 id 为 0 的父类,求其子类与其的层级关系
        getSon(nodeList, node);


    }

    public static void getSon(List<MyNode> nodeList, MyNode node){

        // 用来存子节点
        List<MyNode> nodes = new ArrayList<>();
        int ts = 1; // 层级数
        for (MyNode myNode : nodeList) {

            // 判断得到子节点
            if (myNode.getPid() == node.getId()) {

                // 自己存父亲
                myNode.setPNode(node);

                // 存该对象的子节点,助于下一次调用
                nodes.add(myNode);
                System.out.println("父节点" + "--->" + " 子节点 "+ "--->" +  "层级数");
                // 1:父级的节点  2:自己节点  3:层级数
                getSonId(myNode,myNode,ts);

            }
        }

        // 递归调用得到子节点
        for (MyNode sNode : nodes) {
            getSon(nodeList,sNode);
        }
    }
    public static void getSonId(MyNode pNode,MyNode oldNode,int ts){
        // 父级的节点  --->  自己的节点  ---> 层级数
        System.out.println(pNode.getPid() + "--->" + oldNode.getId() + "--->" +  ts);
        // 判断父级节点是否为最顶层节点,如果不是顶层节点,就继续向上级得到父节点
        if (-1 != pNode.getPNode().getPid()) {
            // 向上是父节点 +1
            ts ++;
            MyNode node = pNode.getPNode();
            getSonId(node,oldNode,ts);
        }
    }
}

测试结果:

父节点---> 子节点 --->层级数
0--->1--->1
0--->2--->1
1--->3--->1
0--->3--->2
1--->4--->1
0--->4--->2
3--->5--->1
1--->5--->2
0--->5--->3

Process finished with exit code 0

本文地址:https://blog.csdn.net/qq_31217363/article/details/107078411