Au niveau de l'Ordre de la traversée d'un générique de l'arbre(n-aire arbre) en java

(Dans le cas où vous souhaitez éviter la longue explication, je suis à la recherche d'un niveau de l'ordre de la traversée pour un générique de l'arbre-(n-aire arbre) en java. Le code fourni des œuvres et des besoins au niveau de l'affichage de l'ordre de la fonction. Regarda autour de lui pour une heure, mais ne pourrais pas trouver de référence génériques n-aire arbres. Serions reconnaissants si soemone peut m'aider à construire l'LevelOrderDisplay fonction sur le dessus de mon code car il va m'aider à comprendre la file d'attente d'erreur que j'obtiens. Merci! )

J'ai essayé de mettre en œuvre une représentation arborescente de Autosys emploi des horaires de travail. Comme chaque tâche(processus) peut avoir un ou ou de plus en plus dépendante de l'emploi sur eux, j'ai décidé d'aller avec un n-aire arbre de la mise en œuvre afin que je puisse la carte de débit. Je suis à l'aide de java collections pour la même chose. J'ai besoin d'exécuter un ordre de niveau de la traversée de l'affichage des dépendances entre les tâches.
La première Impression de la Racine, puis tous les nœuds de niveau un et ensuite tous les nœuds de niveau 2 et ainsi de suite.

J'ai essayé de chercher pendant plus d'une heure sur StackOverflow mais la plupart des exemples que je suis tombé sur l'étaient pour des Arbres Binaires. Je ne comprends que j'ai besoin d'utiliser une file d'attente pour cela.

De ce que j'ai eu lors de mes recherches, l'algorithme devrait ressembler à:
Veuillez me corriger si c'est faux et, si possible, fournir un code pour cela.
D'autres approches sont également les bienvenus, mais ce que je suis vraiment à la recherche d'un simple niveau élémentaire de l'ordre de la traversée d'un générique de l'arbre.

Permet de rendre cela un bon thread pour le générique de l'arbre de la mise en œuvre. La plupart du code est déjà au travail. S'il vous plaît aider.

Algo:

Pour chaque nœud, le premier nœud est visité et puis il est des nœuds enfants sont mis dans une file d'attente FIFO.

printLevelorder(tree)
1) Create an empty queue q
2) temp_node = root /*start from root*/
3) Loop while temp_node is not NULL
    a) print temp_node->data.
    b) Enqueue temp_node’s children (first left then right children) to q
    c) Dequeue a node from q and assign it’s value to temp_node

Pour une raison étrange, je n'ai pas été en mesure de déclarer une file d'attente dans mon IDE Eclipse.
J'ai importé java.util.*;
Il me manque quelque chose ici, veuillez consulter ci-dessous les erreurs.

1ère Tentative:

Queue<NaryTreeNode> BFSqueue = new LinkedList<NaryTreeNode>();

Erreur: Le type LinkedList n'est pas générique; il ne peut pas être paramétrée avec des arguments

2ème Tentative:

QueueList<NaryTreeNode> BFSqueue = new QueueList<NaryTreeNode>();

Erreur: - QueueList ne peut pas être résolu à un type

Actuelle de la Structure de l'Arbre de référence:

     root(100)
    /      |       \
  90       50       70
  /        \
20 30   200  300

La sortie de l'affichage en cours de la fonction est en pré commande:
100 90 20 30 50 200 300 70
J'ai besoin d'un niveau de l'ordre de la traversée pour la même chose.
Sortie requise.

> 100
> 90 50 70
> 20 30 200 300

C'est un code qui fonctionne, si quelqu'un veut l'exécuter sur leur machine et de l'ajouter à l'ordre de niveau de la traversée de la fonction. Veuillez fournir commenté explication pour les opérations de mise en attente car c'est là que je suis bloqué.

Merci!

import java.util.*;
import java.io.*;
import java.util.List;
//The node for the n-ary tree
public class NaryTreeNode {
int data;
List <NaryTreeNode> nary_list = new ArrayList<NaryTreeNode>();
}
public class NaryTree {
void display(NaryTreeNode t) {
if(t==null)
return;
System.out.print(t.data + " ");
for(NaryTreeNode n : t.nary_list) 
display(n) ;            //Recursive Call
}
public static void main(String args[]){
NaryTree t1 = new NaryTree();
NaryTreeNode root = new NaryTreeNode();
root.data = 100;
NaryTreeNode lev_11 = new NaryTreeNode();   lev_11.data=90;
NaryTreeNode lev_12 = new NaryTreeNode();   lev_12.data=50;
NaryTreeNode lev_13 = new NaryTreeNode();   lev_13.data=70;
NaryTreeNode lev_21 = new NaryTreeNode();   lev_21.data=20;
NaryTreeNode lev_22 = new NaryTreeNode();   lev_22.data=30;
NaryTreeNode lev_23 = new NaryTreeNode();   lev_23.data=200;
NaryTreeNode lev_24 = new NaryTreeNode();   lev_24.data=300;
//Add all the nodes to a list.
List<NaryTreeNode> temp2 = new ArrayList<NaryTreeNode>();  //Level two first branch
temp2.add(lev_21);
temp2.add(lev_22);
List<NaryTreeNode> temp3 = new ArrayList<NaryTreeNode>();  //level two second branch
temp3.add(lev_23);
temp3.add(lev_24);
lev_11.nary_list.addAll(temp2);
lev_12.nary_list.addAll(temp3);
List<NaryTreeNode> temp = new ArrayList<NaryTreeNode>();  //level one
temp.add(lev_11);
temp.add(lev_12);
temp.add(lev_13);
//Add Temp to root  to form a leaf of the root
root.nary_list.addAll(temp);
//root=null;
//Call the display function.
t1.display(root);
}
}