在给定节点的情况下使用深度优先遍历算法正向搜索该节点的所有子节点以及反向搜索所有父节点

一、节点的实体类

包含两个字段:
1、该节点的id
2、该节点的父亲id

public class Node {
    private int id;
    private int parentId;
    public Node(int id, int parentId) {
        this.id = id;
        this.parentId = parentId;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public int getParentId() {
        return parentId;
    }
    public void setParentId(int parentId) {
        this.parentId = parentId;
    }
    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", parentId=" + parentId +
                '}';
    }
}

二、深度优先遍历正向搜索该节点的所有子节点

 /**
     * 给定节点,查找该节点下的所有子节点
     * @param current当前节点
     * @param datas所有节点数据的集合
     * @return
     */
    public static List<Node> findAllChild(Node current,List<Node> datas){
        List<Node> childs = new ArrayList<>();
        childs.add(current);
        Stack<Node> stack = new Stack<>();
        stack.push(current);
        while (!stack.isEmpty()){
            Node n = stack.pop();
            datas.forEach(e->{
                if(e.getParentId() == n.getId()){
                    stack.push(e);
                    childs.add(e);
                }
            });
        }
        return childs;
    }

三、深度优先遍历反向搜索所有父节点

 /**
     * 给定节点查找该节点的所有父节点
     * @param node
     * @param data 存储的是所有的节点数据,key为该节点的Id,value为该node
     * @return
     */
    public static List<Node> findAllFather(Node node, HashMap<Integer,Node> data) {
        List<Node> res = new ArrayList<>();
        Stack<Node> stack = new Stack<>();
        stack.push(node);
        while(!stack.isEmpty()){
            //弹出栈顶节点
            Node n  = stack.pop();
            if(n.getId() == n.getParentId()) {
                res.add(n);
                break;
            }
            if(data.containsKey(n.getParentId())){
                Node parent = data.get(n.getParentId());
                res.add(n);
                stack.push(parent);
            }else{
                res.add(n);
            }
        }
        return res;
    }

四、测试代码

public static void main(String[] args) {
        Node n1 = new Node(1, 0);
        Node n2 = new Node(2, 1);
        Node n3 = new Node(3, 2);
        Node n4 = new Node(4, 2);
        Node n5 = new Node(5, 3);
        HashMap<Integer, Node> map = new HashMap<>();
        map.put(n1.getId(),n1);
        map.put(n2.getId(),n2);
        map.put(n3.getId(),n3);
        map.put(n4.getId(),n4);
        map.put(n5.getId(),n5);
        List<Node> nodes = findAllFather(n4, map);
        System.out.println("n4的所有父节点,包括自身");
        System.out.println(nodes);

 		ArrayList<Node> ls = new ArrayList<>();
        ls.add(n1);
        ls.add(n2);
        ls.add(n3);
        ls.add(n4);
        ls.add(n5);
        List<Node> allChild = findAllChild(n2, ls);
        System.out.println("n2的所有子节点,包括自身");
        System.out.println(allChild);
    }

测试结果

在这里插入图片描述

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页