Level Order Iterator

Author: Deepak Malik

src/com/deepak/algorithms/Iterators/LevelOrderIterator.java

@@ -1,5 +1,90 @@
+/**
+ * Algorithms-In-Java
+ * LevelOrderIterator.java
+ */
 package com.deepak.algorithms.Iterators;
 
-public class LevelOrderIterator {
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.NoSuchElementException;
+import java.util.Queue;
+
+import com.deepak.algorithms.Library.TreeNode;
+
+/**
+ * <br> Problem Statement :
+ * 
+ * Implement an iterator that iterates through a binary tree in level order.
+ * 
+ * </br>
+ * 
+ * @author Deepak
+ */
+public class LevelOrderIterator<T> implements Iterator<T> {
+
+	/* Variable for next item to return */
+	private T nextItem;
+	/* Queue to hold items level by level */
+	private final Queue<TreeNode<T>> queue;
+
+	/**
+	 * Constructor
+	 * 
+	 * @param root
+	 */
+	public LevelOrderIterator(TreeNode<T> root) {
+		queue = new LinkedList<>();
+		queue.add(root);
+	}
+
+	/**
+	 * Method to check if next element exists
+	 */
+	@Override
+	public boolean hasNext() {
+		/* If next item exists, return true */
+		if (nextItem != null) {
+			return true;
+		}
+		/* If queue is empty, return false */
+		if (queue.isEmpty()) {
+			return false;
+		}
+		/* Remove the node from the queue */
+		TreeNode<T> node = queue.remove();
+		/* If left or right child exists, add to the queue */
+		if (node.hasLeft()) {
+			queue.add(node.left);
+		}
+		if (node.hasRight()) {
+			queue.add(node.right);
+		}
+		/* Update next item and return true */
+		nextItem = node.item;
+		return true;
+	}
+
+	/**
+	 * Method to find next element 
+	 */
+	@Override
+	public T next() {
+		/* If there is no next element, throw exception */
+		if (!hasNext()) {
+			throw new NoSuchElementException("No Element left in collection!!");
+		}
+		/* Update item to return and next value */
+		T itemToReturn = nextItem;
+		nextItem = null;
+		return itemToReturn;
+	}
+
+	/**
+	 * Method to remove the item
+	 */
+	@Override
+	public void remove() {
+		throw new UnsupportedOperationException("Remove not supported!");
+	}
 
 }

src/com/deepak/algorithms/Library/TreeNode.java

@@ -0,0 +1,38 @@
+/**
+ * Algorithms-In-Java
+ * TreeNode.java
+ */
+package com.deepak.algorithms.Library;
+
+/**
+ * TreeNode class
+ * 
+ * @author Deepak
+ *
+ * @param <T>
+ */
+public class TreeNode<T> {
+
+	/* Data in the node, left child and right child */
+	public T item;
+	public TreeNode<T> left;
+	public TreeNode<T> right;
+
+	/**
+	 * Constructor
+	 * 
+	 * @param item
+	 */
+	public TreeNode(T item) {
+		this.item = item;
+	}
+
+	public boolean hasLeft() {
+		return left != null;
+	}
+
+	public boolean hasRight() {
+		return right != null;
+	}
+
+}

test/com/deepak/algorithms/Iterators/LevelOrderIterator_Test.java

@@ -0,0 +1,74 @@
+/**
+ * Algorithms-in-Java
+ * LevelOrderIterator_Test.java
+ */
+package com.deepak.algorithms.Iterators;
+
+import java.util.NoSuchElementException;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.deepak.algorithms.Library.TreeNode;
+
+/**
+ * Test cases for level order iterator
+ * 
+ * @author Deepak
+ */
+public class LevelOrderIterator_Test {
+
+	/* Root of the tree */
+	private TreeNode<Integer> root;
+
+	/**
+	 * Setup to create a base tree
+	 * 
+	 * 			13
+	 * 	  	  /    \
+	 * 		 7		19
+	 *	    / \    /  \
+	 * 	   3   9  17  23
+	 */
+	@Before
+	public void setup() {
+		root = new TreeNode<Integer>(13);
+		TreeNode<Integer> node2 = new TreeNode<Integer>(7);
+		TreeNode<Integer> node3 = new TreeNode<Integer>(19);
+		TreeNode<Integer> node4 = new TreeNode<Integer>(3);
+		TreeNode<Integer> node5 = new TreeNode<Integer>(9);
+		TreeNode<Integer> node6 = new TreeNode<Integer>(17);
+		TreeNode<Integer> node7 = new TreeNode<Integer>(23);
+
+		/* Setup Tree */
+		root.left = node2;
+		root.right = node3;
+		node2.left = node4;
+		node2.right = node5;
+		node3.left = node6;
+		node3.right = node7;
+	}
+
+	/**
+	 * Test case to check level order iterator
+	 */
+	@Test(expected=NoSuchElementException.class)
+	public void testLevelOrderIterator() {
+		LevelOrderIterator<Integer> iterator = new LevelOrderIterator<>(root);
+		Assert.assertTrue(iterator.hasNext());
+		Assert.assertTrue(iterator.next() == 13);
+		Assert.assertTrue(iterator.next() == 7);
+		Assert.assertTrue(iterator.hasNext());
+		Assert.assertTrue(iterator.next() == 19);
+		Assert.assertTrue(iterator.next() == 3);
+		Assert.assertTrue(iterator.hasNext());
+		Assert.assertTrue(iterator.next() == 9);
+		Assert.assertTrue(iterator.next() == 17);
+		Assert.assertTrue(iterator.hasNext());
+		Assert.assertTrue(iterator.next() == 23);
+		Assert.assertFalse(iterator.hasNext());
+		Assert.assertTrue(iterator.next() == 23);
+	}
+
+}