Cleanup and adding some iterators

Author: deepak-malik

README.md

@@ -133,7 +133,7 @@ Below topics/problems are covered as of now.
 - [ ] Introduction
 - [ ] Array based Implementation
 - [ ] Stack based Implementation 
-- [X] [Dequeue Implementation](../master/src/com/deepak/data/structures/Queue/Dequeue.java)
+- [X] [Dequeue Implementation](../master/src/com/deepak/data/structures/PriorityQueue/Dequeue.java)
 - [ ] Skip List
 
 **14. Trie**

src/com/deepak/data/structures/Cache/LRUCache.java

@@ -1,5 +1,5 @@
 /**
- * Data-Structures-in-Java
+ * Data-Structures-In-Java
  * LRUCache.java
  */
 package com.deepak.data.structures.Cache;

src/com/deepak/data/structures/Cache/MRUCache.java

@@ -1,5 +1,5 @@
 /**
- * Data-Structures-in-Java
+ * Data-Structures-In-Java
  * MRUCache.java
  */
 package com.deepak.data.structures.Cache;

src/com/deepak/data/structures/Iterators/HoppingIterator.java

@@ -0,0 +1,105 @@
+/**
+ * Data-Structures-In-Java
+ * HoppingIterator.java
+ */
+package com.deepak.data.structures.Iterators;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/**
+ * <br> Problem Statement :
+ * 
+ * Implement an iterator that hops specified number of times and then returns the next
+ * element after the hop. Note: the iterator always returns the first element as
+ * it is, and starts hopping only after the first element.
+ *
+ * Examples:
+ *
+ * If the original iterator returns: [1, 2, 3, 4, 5] in order, then the hopping
+ * iterator will return [1, 3, 5] in order when the hop value is 1.
+ *
+ * If the original iterator returns: [1, 2, 3, 4, 5] in order, then the hopping
+ * iterator will return [1, 4] in order when the hop value is 2.
+ *
+ * If the original iterator returns: [1, 2, 3, 4, 5] in order, then the hopping
+ * iterator will return [1, 5] in order when the hop value is 3.
+ * 
+ * </br>
+ * 
+ * @author Deepak
+ */
+public class HoppingIterator<T> implements Iterator<T> {
+
+	/* Iterator */
+	private final Iterator<T> iterator;
+	/* Variable to keep track of next item */
+	private T nextItem;
+	/* Number of hops needed */
+	private final int numOfHops;
+	/* Flag to check if it is first element */
+	private boolean first;
+
+	/**
+	 * Constructor 
+	 * 
+	 * @param iterator
+	 * @param numOfHops
+	 */
+	public HoppingIterator(Iterator<T> iterator, int numOfHops) {
+		if (numOfHops < 0) {
+			throw new IllegalArgumentException("Invalid value for number of hops!!");
+		}
+		this.iterator = iterator;
+		this.numOfHops = numOfHops;
+		nextItem = null;
+		first = true;
+	}
+
+	/**
+	 * Method to check of next element exists
+	 */
+	@Override
+	public boolean hasNext() {
+		/* If we already have next item, return true */
+		if (nextItem != null) {
+			return true;
+		}
+		/* If it is not first element, move till the next hop */
+		if (!first) {
+			for (int hop = 0; hop < numOfHops && iterator.hasNext(); hop++) {
+				iterator.next();
+			}
+		}
+		/* Now, if next element exits. move there and update first flag */
+		if (iterator.hasNext()) {
+			nextItem = iterator.next();
+			first = false;
+		}
+		return nextItem != null;
+	}
+
+	/**
+	 * Method to find next element in collection
+	 */
+	@Override
+	public T next() {
+		/* If no next element exits, collection has finished */
+		if (!hasNext()) {
+			throw new NoSuchElementException("No Element left in collection!!");
+		}
+		/* Else, find the next item, return it and set next item to null */
+		T itemToReturn = nextItem;
+		nextItem = null;
+		return itemToReturn;
+	}
+
+	/**
+	 * Method to remove the element
+	 */
+	@Override
+	public void remove() {
+		throw new UnsupportedOperationException("Remove not supported!!");
+	}
+
+}

src/com/deepak/data/structures/Iterators/InOrderIterator.java

@@ -0,0 +1,23 @@
+package com.deepak.data.structures.Iterators;
+
+import java.util.Iterator;
+
+public class InOrderIterator<T> implements Iterator<T> {
+
+
+	@Override
+	public boolean hasNext() {
+		return false;
+	}
+
+	@Override
+	public T next() {
+		return null;
+	}
+
+	@Override
+	public void remove() {
+		throw new UnsupportedOperationException("Remove not supported!!");
+	}
+
+}

src/com/deepak/data/structures/Iterators/LevelOrderIterator.java

@@ -0,0 +1,121 @@
+/**
+ * Data-Structures-In-Java
+ * LevelOrderIterator.java
+ */
+package com.deepak.data.structures.Iterators;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.NoSuchElementException;
+import java.util.Queue;
+
+/**
+ * <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!");
+	}
+
+	/**
+	 * TreeNode class
+	 * 
+	 * @author Deepak
+	 *
+	 * @param <E>
+	 */
+	public static class TreeNode<E> {
+
+		/* Data in the node, left child and right child */
+		public E item;
+		public TreeNode<E> left;
+		public TreeNode<E> right;
+
+		/**
+		 * Constructor
+		 * 
+		 * @param item
+		 */
+		public TreeNode(E item) {
+			this.item = item;
+		}
+
+		public boolean hasLeft() {
+			return left != null;
+		}
+
+		public boolean hasRight() {
+			return right != null;
+		}
+
+	}
+
+}

src/com/deepak/data/structures/Iterators/MaxIterator.java

@@ -0,0 +1,84 @@
+/**
+ * Data-Structures-In-Java
+ * MaxIterator.java
+ */
+package com.deepak.data.structures.Iterators;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/**
+ * <br> Problem Statement :
+ * 
+ * Implement a max iterator i.e. it always returns the next item in the list
+ * bigger than the last item returned.
+ * 
+ * </br>
+ * 
+ * @author Deepak
+ */
+public class MaxIterator<T> implements Iterator<T> {
+
+	/* Iterator and Comparator */
+	private final Iterator<T> iterator;
+	private final Comparator<T> comparator;
+	/* Variables to store last item and next item */
+	private T lastItem;
+	private T nextItem;
+
+	/**
+	 * Constructor
+	 * 
+	 * @param iterator
+	 * @param comparator
+	 */
+	public MaxIterator(Iterator<T> iterator, Comparator<T> comparator) {
+		this.iterator = iterator;
+		this.comparator = comparator;
+	}
+
+	/**
+	 * Method to check if next element exists
+	 */
+	@Override
+	public boolean hasNext() {
+		/* If next item is not null, return true */
+		if (nextItem != null) {
+			return true;
+		}
+		/* Else go through the collection and find the next bigger element */
+		while (nextItem == null && iterator.hasNext()) {
+			T item = iterator.next();
+			if (lastItem == null || comparator.compare(item, lastItem) > 0) {
+				nextItem = item;
+			}
+		}
+		/* Return true if exists */
+		return nextItem != null;
+	}
+
+	/**
+	 * Method to find next element
+	 */
+	@Override
+	public T next() {
+		/* If next element doesn't exists, throw exception */
+		if (!hasNext()) {
+			throw new NoSuchElementException("No element found in collection!!");
+		}
+		/* Else update the last item found */
+		lastItem = nextItem;
+		nextItem = null;
+		return lastItem;
+	}
+
+	/**
+	 * Method to remove the element
+	 */
+	@Override
+	public void remove() {
+		throw new UnsupportedOperationException("Remove not supported!!");
+	}
+
+}

src/com/deepak/data/structures/Iterators/PostOrderIterator.java

@@ -0,0 +1,7 @@
+package com.deepak.data.structures.Iterators;
+
+public class PostOrderIterator {
+
+
+
+}