N叉树的最大宽度

这里的思路是N叉树的层序遍历

（递归法）

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;
 
    public Node() {}
 
    public Node(int _val,List<Node> _children) {
        val = _val;
        children = _children;
    }
};

public class levelOrder {
    public static void main(String[] args) {
 
    }
    static List<List<Integer>> returnList = new ArrayList<>();
    public static List<List<Integer>> levelOrder(Node root) {
        if(root == null){
            return returnList;
        }
 
        if(root.children == null){
             returnList.get(0).add(root.val);
             return returnList;
        }
 
        helper(root,0);
        return returnList;
    }
 
    private static void helper(Node root,int index) {
        if (returnList.size() == index) {
            returnList.add(new ArrayList<>());
        }
        returnList.get(index).add(root.val);
        for (int i = 0; i <root.children.size() ; i++) {
            helper(root.children.get(i),index +1);
        }
    }
}
*/

队列（广度优先遍历）

public static void main(String[] args) {
 
        Node node2 = new Node();
        node2.val = 2;
        Node node4 = new Node();
        node4.val = 4;
        Node node5 = new Node();
        node5.val = 5;
        Node node6 = new Node();
        node6.val = 6;
 
        List<Node> Node2 = new ArrayList<>();
        Node2.add(node5);
        Node2.add(node6);
        Node node3 = new Node(3,Node2);
 
        List<Node> Node1 = new ArrayList<>();
        Node1.add(node3);
        Node1.add(node2);
        Node1.add(node4);
 
        Node node1 = new Node(1,Node1 );
        System.out.println(levelOrder(node1));
//        List<List<Integer>> returnList = levelOrder(node1);
//        for (int i = 0; i <returnList.size() ; i++) {
//            for (int j = 0; j <returnList.get(i).size() ; j++) {
//                System.out.print(returnList.get(i).get(j));
//            }
//        }
    }
    public static List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int count = queue.size();
            //外层循环为一层
            List<Integer> list = new ArrayList<>();
            while (count-- > 0) {
                //将当前元素的非空子节点压入栈
                Node cur = queue.poll();
                list.add(cur.val);
                if(cur.children != null){
                    for (Node node : cur.children) {
                        if (node != null) {
                            queue.add(node);
                        }
                    }
                }
            }
            res.add(list);
        }
        return res;
    }
}

以上部分是N叉树的层序遍历

求最大的宽度

思路（其实就是先进行层次遍历，然后对所有的List进行遍历，计算最长的）

relationList为模拟的n叉树，appointSale为随机一个点。求这个随机点的子树下的最大宽度

    private static int[] max(Map<Integer, List<Integer>> relationList, int appointSale) {
        List<List<Integer>> res = new ArrayList<>();
        LinkedList<Integer> ans = new LinkedList<>();
        ans.add(appointSale);
        while (!ans.isEmpty()){
            int count = ans.size();
            List<Integer> unFinds = new ArrayList<>();
            while (count-- > 0){
                int temp = ans.pop();
                unFinds.add(temp);
                if(relationList.containsKey(temp)){
                    List<Integer> tempList = relationList.get(temp);
                    for (int i = 0; i < tempList.size(); i++) {
                        ans.add(tempList.get(i));
                    }
                }
            }
            res.add(unFinds);
        }
        int max = 0;
        int index = 0;
        for (int i = 0; i < res.size(); i++) {
            if(res.get(i).size() > max){
                max = Math.max(max,res.get(i).size());
                index = i + 1;
            }
        }
        int[] tempVec= new int[2];
        tempVec[0] = index;
        tempVec[1] = max;
        return tempVec;
    }

本公众号分享自己从程序员小白到经历春招秋招斩获10几个offer的面试笔试经验，其中包括【Java】、【操作系统】、【计算机网络】、【设计模式】、【数据结构与算法】、【大厂面经】、【数据库】期待你加入！！！

1.计算机网络----三次握手四次挥手
2.梦想成真-----项目自我介绍
3.你们要的设计模式来了
4.一字一句教你面试“个人简介”
5.接近30场面试分享