来未来面试真题：根据树形表输出树形结构

根据以下所给代码补充完printNode方法，要求输出如下形式的树形结构

package com.ting.sort;

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

public class Menu {
    static class Node{
        Integer id;
        Integer parentId;
        String name;
        Node(Integer id,Integer parentId,String name){
            this.id=id;
            this.parentId=parentId;
            this.name=name;
        }
    }

    public static void main(String[] args) {
        ArrayList<Node> nodeArrayList = new ArrayList<>();
        nodeArrayList.add(new Node(1,0,"AA"));
        nodeArrayList.add(new Node(2,1,"BB"));
        nodeArrayList.add(new Node(3,1,"CC"));
        nodeArrayList.add(new Node(4,2,"DD"));
        nodeArrayList.add(new Node(5,1,"EE"));
        nodeArrayList.add(new Node(6,3,"FF"));
        nodeArrayList.add(new Node(7,0,"EE"));
        printNode(nodeArrayList);
    }
    //在此补充代码
    private static void printNode(ArrayList<Node> nodeArrayList) {

    }
}

 分析

输出

0的儿子有1、7，1的儿子有2、3、5，2的儿子有4，3的儿子有6，4没儿子，5没儿子，6没儿子，7没儿子。显然是用递归的方法输出。根据父亲找儿子，再遍历儿子，找儿子的儿子....所以只需要把最小的父亲传入。

收集父亲的儿子们 

那首先就要计算出父亲以及它的儿子们。最好是这种形式{0=[1, 7], 1=[2, 3, 5], 2=[4], 3=[6]}。以父亲作为key，儿子列表为value。用hashmap是最好的选择，遍历nodeArrayList，若该父亲（key）不存在则new ArrayList<>()作为value加入hashmap；存在则获取原有的value（list），在此基础上add(node.id)。

        HashMap<Integer, List<Integer>> hashMap = new HashMap<>();
        for (Node node : nodeArrayList) {
            if(hashMap.get(node.parentId)==null){
                ArrayList<Integer> list = new ArrayList<>();
                list.add(node.id);
                hashMap.put(node.parentId,list);
            }else {
                List<Integer> integerList = hashMap.get(node.parentId);
                integerList.add(node.id);
                hashMap.put(node.parentId,integerList);
            }
        }

代码很简单 但写起来复杂吧。上面那些只需要用一行代码便可以解决

释意：若以node.parentId为key的entry存在，则在其value基础上add，若不存在则new一个新ArrayList再add。

        HashMap<Integer, List<Integer>> hashMap = new HashMap<>();
        for (Node node : nodeArrayList) {
            hashMap.computeIfAbsent(node.parentId,k->new ArrayList<>()).add(node.id);
        }

保证有序

但是hashmap是无序的，只是恰好 nodeArrayList 的parentId出现的顺序都是有序的，那么就需要先把最小的父亲找出来，但是初值应该赋什么呢？不好确定，太大效率低，太小不确定有没有比他更小的。所以直接赋值为nodeArrayList第一个节点的parentId。

//        最小的父亲初值为第一个节点的父亲
        Integer minParentId=nodeArrayList.get(0).parentId;
//        遍历 找到最小父亲
        for (Node node : nodeArrayList) {
            if(node.parentId<minParentId){
                minParentId=node.parentId;
            }
        }
        System.out.println(minParentId+"最小的父亲");

递归

拿到父亲和儿子了，也拿到了最小的父亲，接下来就是遍历输出了。 先输出父亲，再根据父亲查询其儿子也就是根据hashmap中的key找到value，若没有儿子直接返回，结束递归。有则遍历儿子，输出空格，递归调用该方法，但count+1，因为每递归一次说明是儿子。第一次调用该方法应为

method(hashMap,minParentId,0);

   private static void method(HashMap<Integer,List<Integer>> hashMap,Integer queryId,int count){
        System.out.println(queryId);
        List<Integer> ids = hashMap.get(queryId);
        if(ids==null){
            return;
        }else if (ids.size()>0&&ids!=null){
            for (Integer id : ids) {
                printSp(count);
                method(hashMap,id,count+1 );
            }
        }
    }
    private static void printSp(int count){
        for (int i=0;i<count;i++)
            System.out.print("  ");
    }

完整代码

package com.ting.sort;

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

public class Menu {
    static class Node{
        Integer id;
        Integer parentId;
        String name;
        Node(Integer id,Integer parentId,String name){
            this.id=id;
            this.parentId=parentId;
            this.name=name;
        }
    }

    public static void main(String[] args) {
        ArrayList<Node> nodeArrayList = new ArrayList<>();
        nodeArrayList.add(new Node(1,0,"AA"));
        nodeArrayList.add(new Node(2,1,"BB"));
        nodeArrayList.add(new Node(3,1,"CC"));
        nodeArrayList.add(new Node(4,2,"DD"));
        nodeArrayList.add(new Node(5,1,"EE"));
        nodeArrayList.add(new Node(6,3,"FF"));
        nodeArrayList.add(new Node(7,0,"EE"));
        printNode(nodeArrayList);
    }
    private static void printNode(ArrayList<Node> nodeArrayList) {
        //todo
//        最小的父亲初值为第一个节点的父亲
        Integer minParentId=nodeArrayList.get(0).parentId;
//        遍历 找到最小父亲
        for (Node node : nodeArrayList) {
            if(node.parentId<minParentId){
                minParentId=node.parentId;
            }
        }
        System.out.println(minParentId+"最小的父亲");
//        将父亲id和出现次数存入hashmap
        HashMap<Integer, List<Integer>> hashMap = new HashMap<>();
        for (Node node : nodeArrayList) {
            hashMap.computeIfAbsent(node.parentId,k->new ArrayList<>()).add(node.id);
        }
        System.out.println(hashMap);
        method(hashMap,minParentId,0);
    }
    private static void method(HashMap<Integer,List<Integer>> hashMap,Integer queryId,int count){
        System.out.println(queryId);
        List<Integer> ids = hashMap.get(queryId);
        if(ids==null){
            return;
        }else if (ids.size()>0&&ids!=null){
            for (Integer id : ids) {
                printSp(count);
                method(hashMap,id,count+1 );
            }
        }
    }
    private static void printSp(int count){
        for (int i=0;i<count;i++)
            System.out.print("  ");
    }
}

 0可以在输出前判断去掉