Tree$234$Iterator.java import java.util.$*$;

public class Tree$234$Iterator implements Iterator $\{$

$//$ Your code here

public Tree$234$Iterator$($Node$234$ treeRootNode$)\{$

$//$ Your code here

$\}$

public boolean hasNext$()\{$

$//$ Your code here $($remove placeholder line below$)$

return false;

$\}$

public Integer next$()\{$

$//$ Your code here $($remove placeholder line below$)$

return $0$;

$\}$

$\}$LabProgram$.$java import java.io$.*$;

import java.util.$*$;

import java.util.concurrent.ThreadLocalRandom;

public class LabProgram $\{$

public static void main$($String$[]$ args$)\{$

$//$ Create a new Tree$234$ instance

Tree$234$ tree $=$ new Tree$234()$;

$//$ Generate and insert random integers

ThreadLocalRandom rand $=$ ThreadLocalRandom.current$()$;

ArrayList expected $=$ new ArrayList$()$;

HashSet added $=$ new HashSet$()$;

for $($int i $=0$; expected.size$()<mtext></mtext><mn>2</mn><mn>0</mn>$; i$++)\{$

int randomInteger $=$ rand.nextInt$(100,1000)$;

if $(!$added.contains$($randomInteger$))\{$

added.add$($randomInteger$)$;

expected.add$($randomInteger$)$;

tree.insert$($randomInteger$)$;

$\}$

$\}$

Collections.sort$($expected$)$;

$//$ Build the actual list of integers by iterating through the tree. Keep

$//$ track of the number of iterations and if more iterations occur than

$//$ expected, then stop.

ArrayList actual $=$ new ArrayList$()$;

int iterationCount $=0$;

for $($Integer actualInt : tree$)\{$

actual.add$($actualInt$)$;

iterationCount$++$;

$//$ If this iteration exceeded the expected number of iterations then

$//$ print a failure message

if $($iterationCount $>$ expected.size$())\{$

System.out.print$("$FAIL: More than the expected $"+$ expected.size$())$;

System.out.println$("$ iterations, occurred. The iterator's $"+$

"hasNext$()$ method implementation may be incorrect."$)$;

return;

$\}$

$\}$

$//$ Print the pass or fail messsage

System.out.print$($expected$.$equals$($actual$)?$ "PASS" : "FAIL"$)$;

System.out.println$("$: Iteration through tree's keys:"$)$;

System.out.println$("$ Actual: $"+$ actual$)$;

System.out.println$("$ Expected: $"+$ expected$)$;

$\}$

$\}$ Node$234.$java $//$ Node$234$ class $-$ represents a node in a $2-3-4$ tree

class Node$234\{$

protected int A;

protected int B;

protected int C;

protected int keyCount;

protected Node$234$ left;

protected Node$234$ middle$1$;

protected Node$234$ middle$2$;

protected Node$234$ right;

public Node$234($int keyA$)\{$

this$($keyA$,$ null, null$)$;

$\}$

public Node$234($int keyA, Node$234$ leftChild, Node$234$ middle$1$Child$)\{$

A $=$ keyA;

B $=0$;

C $=0$;

keyCount $=1$;

left $=$ leftChild;

middle$1=$ middle$1$Child;

middle$2=$ null;

right $=$ null;

$\}$

$//$ Appends $1$ key and $1$ child to this node.

$//$ Preconditions:

$//1.$ This node has $1$ or $2$ keys

$//2.$ key $>$ all keys in this node

$//3.$ Child subtree contains only keys $>$ key

public void appendKeyAndChild$($int key, Node$234$ child$)\{$

if $($keyCount $==1)\{$

B $=$ key;

middle$2=$ child;

$\}$

else $\{$

C $=$ key;

right $=$ child;

$\}$

keyCount$++$;

$\}$

$//$ Returns the left, middle$1,$ middle$2,$ or right child if the childIndex

$//$ argument is $0,1,2,$ or $3,$ respectively.

$//$ Returns null if the childIndex argument is $<mtext></mtext><mn>0</mn>$ or $>3.$

public Node$234$ getChild$($int childIndex$)\{$

if $($childIndex $==0)\{$

return left;

$\}$

else if $($childIndex $==1)\{$

return middle$1$;

$\}$

else if $($childIndex $==2)\{$

return middle$2$;

$\}$

else if $($childIndex $==3)\{$

return right;

$\}$

return null;

$\}$

$//$ Returns $0,1,2,$ or $3$ if the child argument is this node's left,

$//$ middle$1,$ middle$2,$ or right child, respectively.

$//$ Returns $-1$ if the child argument is not a child of this node.

public int getChildIndex$($Node$234$ child$)\{$

if $($child $==$ left$)\{$

return $0$;

$\}$

else if $($child $==$ middle$1)\{$

return $1$;

$\}$

else if $($child $==$ middle$2)\{$

return $2$;

$\}$

else if $($child $==$ right$)\{$

return $3$;

$\}$

return $-1$;

$\}$

$//$ Returns this node's A$,$ B$,$ or C key, if the keyIndex argument is

$//0,1,$ or $2,$ respectively.

$//$ Returns $0$ if the keyIndex argument is $<mtext></mtext><mn>0</mn>$ or $>2.$

public int getKey$($int keyIndex$)\{$

if $($keyIndex $==0)\{$

return A;

$\}$

else if $($keyIndex $==1)\{$

return B;

$\}$

else if $($keyIndex $==2)\{$

return C;

$\}$

return $0$;

$\}$

$//$ Returns this node's key count.

public int getKeyCount$()\{$

return keyCount;

$\}$

$//$ Returns $0,1,$ o