class Node {
	public int val;
	public List<Node> children;
	Node(int val) {
		this.val = val;
		this.children = new ArrayList<>();
	}
}

Parcours

Profondeur d’abord

boolean contains(Node n, int val) {
	if(n.val == val) return true;
	
	for(Node fils : n.children) {
		boolean rep = contains(fils, val);
		if(rep) return true;
	}
	
	return false;
}

int treeDepth(Node n, int level) {
	if(n.children.isEmpty()) return level;
	int    nnDepth = 0;
	
	for(Node fils : n.children) {
		int d = treeDepth(fils, level+1);
		if(d > maxDepth) maxDepth = d;
	}
	
	return maxDepth;
}

int treeDepth(Node n) {
	if(n.children.isEmpty()) return 1;
	int maxDepth = 0;
	
	for(Node fils : n.children) {
		int d = treeDepth(fils);
		if(d > maxDepth) maxDepth = d;
	}
	
	return maxDepth + 1;
}

int nbLeaves(Node n) {
	if(n.children.isEmpty()) return 1;
	
	int nb = 0;
	for(Node fils : n.children) {
		nb += nbLeaves(fils);
	}
	
	return nb;	
}

Largeur d’abord

boolean contains(Node n, int val) {
	if(n.val == val) return true;
	
	Queue<Node> queue = new ArrayDeque<>();
	for(Node fils : n.children) {
		queue.offer(fils);
	}
	
	while(!queue.isEmpty()) {
		Node p = queue.poll();
		if(p.val == val) return true;
		
		queue.addAll(p.children);
	}
	
	return false;
}

List<Node> getNodesForLevel(Node n, int level) {
	List<Node> list = new ArrayList<>();
	if(level == 0) list.add(n);
	else if(level > 0) {
		int curLevel = 1;
		Node separ = new Node(-9999);
		Queue<Node> queue = new ArrayDeque<>();
		
		for (Node f : n.children) queue.offer(f);
		queue.offer(separ);
		
		while(!queue.isEmpty())  {
			Node p = queue.poll();
			if(p == separ) {
				if(curLevel == level) return list;
				curLevel += 1;
				queue.offer(separ);
			}
		}
	} else {
		if(curLevel == level) {
			list.add(p);
		} else {
			for(Node f : p.children)
			queue.offer(f);
		}
	}
	
	return list;
}