Level order traversal of n-ary tree

import java.util.Vector;
import java.util.ArrayList;
// Java program for
// Iterative Level Order Traversal of an N-ary Tree
class TreeNode
{
    public int key;
    public Vector < TreeNode > child;
    public TreeNode(int key)
    {
        // Set node key
        this.key = key;
        // Create memory of TreeNode child
        this.child = new Vector < TreeNode > ();
    }
    public void addChild(int key)
    {
        // Create a new node
        TreeNode node = new TreeNode(key);
        // Add node into child
        this.child.add(node);    }
}

class QNode
{
    public TreeNode node;
    public QNode next;
    public QNode(TreeNode node)
    {
        this.node = node;
        this.next = null;
    }
}
// Define custom queue class
class MyQueue
{
    public QNode front;
    public QNode rear;
    public int size;
    public MyQueue()
    {
        this.front = null;
        this.rear = null;
        this.size = 0;
    }
    // Add a new node at last of queue
    public void enqueue(TreeNode n)
    {
        QNode node = new QNode(n);
        if (this.front == null)
        {
            // When first node of queue
            this.front = node;
        }
        else
        {
            // Add node at last level
            this.rear.next = node;
        }
        this.size++;
        this.rear = node;
    }
    // Delete front node of queue
    public void dequeue()
    {
        if (this.front != null)
        {
            if (this.rear == this.front)
            {
                this.rear = null;
                this.front = null;
            }
            else
            {
                this.front = this.front.next;
            }
            this.size--;
        }
    }
    public int isSize()
    {
        return this.size;
    }
    public boolean isEmpty()
    {
        if (this.isSize() == 0)
        {
            return true;
        }
        return false;
    }
    public TreeNode peek()
    {
        if (this.isSize() == 0)
        {
            return null;
        }
        else
        {
            return this.front.node;
        }
    }
}
public class NAryTree
{
    public TreeNode root;

    public NAryTree()
    {
        // Set initial tree root to null
        this.root = null;
    }
   
    public void printLevelOrder()
    {
        if(this.root == null)
        {
            return;
        }
        MyQueue record = new MyQueue();

        // Add first node
        record.enqueue(this.root);

        TreeNode node = null;

        while(record.isEmpty() == false)
        {
            // Get front node
            node = record.peek();

            // Remove front node
            record.dequeue();

            // Display node value
            System.out.print("  "+node.key);

            for (int i = 0; i < node.child.size()  ; ++i) 
            {
                // Collect child node
                record.enqueue(node.child.get(i));
            }

        }

    }
    public static void main(String[] args)
    {
        NAryTree tree = new NAryTree();
        /*
                   10
                  /   \
                 /     \
                /       \   
               8         5
              /|\      /|\ \ 
             / | \    / | \ \
            -2 1  6  7 18 3  4
              / \           /| \
             9  11         2 1  3
               /  \          |
              17   12        15
            -----------------------
            Constructing N-Arr tree
        */
        // First element of tree
        tree.root = new TreeNode(10);
        tree.root.addChild(8);
        tree.root.addChild(5);
        // Add child node [-2,1,6] in node (8)
        tree.root.child.get(0).addChild(-2);
        tree.root.child.get(0).addChild(1);
        tree.root.child.get(0).addChild(6);
        // Add child node [9,11] in node (1)
        tree.root.child.get(0).child.get(1).addChild(9);
        tree.root.child.get(0).child.get(1).addChild(11);
        // Add child node [17  12] in node (11)
        tree.root.child.get(0).child.get(1).child.get(1).addChild(17);
        tree.root.child.get(0).child.get(1).child.get(1).addChild(12);
        // Add child node [7 18 3 4] in node (5)
        tree.root.child.get(1).addChild(7);
        tree.root.child.get(1).addChild(18);
        tree.root.child.get(1).addChild(3);
        tree.root.child.get(1).addChild(4);
        // Add child node [2,1,3] in node (4)
        tree.root.child.get(1).child.get(3).addChild(2);
        tree.root.child.get(1).child.get(3).addChild(1);
        tree.root.child.get(1).child.get(3).addChild(3);
		 // Add child node [15] in node (1)
      	tree.root.child.get(1).child.get(3).child.get(1).addChild(15);
        tree.printLevelOrder();
    }
}

Output

  10  8  5  -2  1  6  7  18  3  4  9  11  2  1  3  17  12  15