updated code to use ArrayDeque

Author: RodneyShag

src/chapter02/TwoPoint7.java

@@ -1,6 +1,6 @@
 package chapter02;
 
-import java.util.Stack;
+import java.util.ArrayDeque;
 
 /* Check if Linked List is a palindrome
  * 
@@ -14,9 +14,9 @@ public class TwoPoint7 {
 	public static boolean palindrome_2(Node head) {
 		Node slow = head;
 		Node fast = head;
-		Stack<Integer> stack = new Stack<>();
+		ArrayDeque<Integer> deque = new ArrayDeque<>(); // use deque as a stack
 		while (fast != null && fast.next != null) {
-			stack.push(slow.data);
+			deque.push(slow.data);
 			slow = slow.next;
 			fast = fast.next.next;
 		}
@@ -25,7 +25,7 @@ public static boolean palindrome_2(Node head) {
 			slow = slow.next;
 		}
 		while (slow != null) {
-			if (stack.pop() != slow.data) {
+			if (deque.pop() != slow.data) {
 				return false;
 			}
 			slow = slow.next;

src/chapter03/MyQueue.java

@@ -4,8 +4,8 @@
 
 /* This is problem 3.5 */
 public class MyQueue<T> { // class is parameterized!
-	private Stack<T> stack1 = new Stack<T>();
-	private Stack<T> stack2 = new Stack<T>();
+	private Stack<T> stack1 = new Stack<>();
+	private Stack<T> stack2 = new Stack<>();
 
 	public int size() {
 		return stack1.size() + stack2.size();

src/chapter03/ThreePoint2.java

@@ -3,6 +3,7 @@
 import java.util.Stack;
 
 public class ThreePoint2 {
+	/* Can alternatively use ArrayDeque (it's faster) */
 	Stack<Integer> stack    = new Stack<>();
 	Stack<Integer> minStack = new Stack<>(); // keeps track of minimums
 

src/chapter03/ThreePoint3.java

@@ -1,7 +1,7 @@
 package chapter03;
 
 import java.util.ArrayList;
-import java.util.Stack;
+import java.util.Stack; // can alternatively use ArrayDeque (it's faster)
 
 public class ThreePoint3 {
 	private ArrayList<Stack<Integer>> stacks = new ArrayList<Stack<Integer>>();

src/chapter03/ThreePoint4.java

@@ -1,6 +1,6 @@
 package chapter03;
 
-import java.util.Stack;
+import java.util.ArrayDeque;
 
 public class ThreePoint4 {
 	public static void moveDisks(int n, Tower origin, Tower destination, Tower buffer) {
@@ -21,12 +21,12 @@ public static void moveTop(Tower origin, Tower destination) {
 
 /* It's just a stack, including 1) Error Checking 2) tower number */
 class Tower {
-	private Stack<Integer> disks;
+	private ArrayDeque<Integer> disks; // use deque as a stack
 	public int towerNum;
 
 	/* Constructor */
 	public Tower(int towerNum) {
-		disks = new Stack<>();
+		disks = new ArrayDeque<>();
 		this.towerNum = towerNum;
 	}
 

src/chapter03/ThreePoint6.java

@@ -8,7 +8,7 @@
 public class ThreePoint6 {
 	/* Clever Algorithm */
 	public static Stack<Integer> sort(Stack<Integer> stack) {
-		Stack<Integer> helperStack = new Stack<Integer>();
+		Stack<Integer> helperStack = new Stack<Integer>(); // can alternatively use ArrayDeque (it's faster)
 		while (!stack.isEmpty()) {
 			Integer curr = stack.pop(); // saving the top of the stack is one of the main tricks.
 			while (!helperStack.isEmpty() && curr < helperStack.peek()) {

src/chapter04/FourPoint2.java

@@ -1,7 +1,6 @@
 package chapter04;
 
-import java.util.Queue;
-import java.util.LinkedList;
+import java.util.ArrayDeque;
 
 public class FourPoint2 {
 	/* We do BFS from start node to see if we arrive at end node */
@@ -10,19 +9,19 @@ public static boolean routeExists(GraphNode start, GraphNode end){
 			return true;
 		}
 
-		Queue<GraphNode> queue = new LinkedList<>();
+		ArrayDeque<GraphNode> deque = new ArrayDeque<>(); // use deque as a queue
 		start.visit();
-		queue.add(start);
+		deque.add(start);
 
-		while ( ! queue.isEmpty()) {
-			GraphNode curr = queue.remove();
+		while (!deque.isEmpty()) {
+			GraphNode curr = deque.remove();
 			if (curr == end) {
 				return true;
 			}
 			for (GraphNode neighbor : curr.getNeighbors()) {
 				if ( ! neighbor.visited) {
 					neighbor.visit();
-					queue.add(neighbor);
+					deque.add(neighbor);
 				}
 			}
 		}

src/chapter04/GraphFunctions.java

@@ -1,7 +1,6 @@
 package chapter04;
 
-import java.util.Queue;
-import java.util.LinkedList;
+import java.util.ArrayDeque;
 
 public class GraphFunctions {
 
@@ -10,7 +9,7 @@ public static void connectNodes(GraphNode node1, GraphNode node2) {
 		node2.addNeighbor(node1);
 	}
 
-	/* I do this recursively. Can alternatively do it like BFS (below) but using a Stack instead of a Queue. */
+	/* I do this recursively. Can alternatively do it like BFS (below) by using a Stack instead of a Queue. */
 	public static void DFS(GraphNode node, int data) {
 		if (node == null) {
 			return;
@@ -40,12 +39,12 @@ public static void BFS(GraphNode node, int data) {
 			return;
 		}
 
-		Queue<GraphNode> queue = new LinkedList<>();
+		ArrayDeque<GraphNode> deque = new ArrayDeque<>(); // use deque as a queue
 		node.visit();
-		queue.add(node);
+		deque.add(node);
 
-		while ( ! queue.isEmpty()) {
-			GraphNode curr = queue.remove();
+		while (!deque.isEmpty()) {
+			GraphNode curr = deque.remove();
 
 			if (curr.data == data) {
 				System.out.println("BFS found the GraphNode with desired data: " + curr.data);
@@ -55,7 +54,7 @@ public static void BFS(GraphNode node, int data) {
 			for (GraphNode neighbor : curr.getNeighbors()) {
 				if ( ! neighbor.visited) {
 					neighbor.visit();   // make sure to visit node BEFORE we put it on queue instead of when we take it off (to avoid duplicates on queue)
-					queue.add(neighbor);
+					deque.add(neighbor);
 				}
 			}
 		}

src/chapter04/TreeFunctions.java

@@ -1,7 +1,6 @@
 package chapter04;
 
-import java.util.Queue;
-import java.util.LinkedList;
+import java.util.ArrayDeque;
 
 /* I thought it'd be useful to make this class */
 public class TreeFunctions {
@@ -65,16 +64,16 @@ public static void printPostOrder(TreeNode node) {
 
 	/* Prints tree level 0, 1, ... n */
 	public static void printLevelOrder(TreeNode root) {
-		Queue<TreeNode> queue = new LinkedList<>(); // Queue is an interface, so we use a LinkedList
-		queue.add(root);
-		while ( ! queue.isEmpty()) {
-			TreeNode n = queue.remove();
+		ArrayDeque<TreeNode> deque = new ArrayDeque<>(); // use deque as a queue
+		deque.add(root);
+		while (!deque.isEmpty()) {
+			TreeNode n = deque.remove();
 			System.out.print(n + " ");
 			if (n.left != null) {
-				queue.add(n.left);
+				deque.add(n.left);
 			}
 			if (n.right != null) {
-				queue.add(n.right);
+				deque.add(n.right);
 			}
 		}
 	}

src/chapter07/SevenPoint7.java

@@ -1,7 +1,6 @@
 package chapter07;
 
-import java.util.Queue;
-import java.util.LinkedList;
+import java.util.ArrayDeque;
 
 /* Finds kth magic number
  * 
@@ -25,13 +24,15 @@ public static int getKthMagicNumber(int k) {
 		if (k < 0) {
 			return -1;
 		}
-		Queue<Integer> q3 = new LinkedList<Integer>();
-		Queue<Integer> q5 = new LinkedList<Integer>();
-		Queue<Integer> q7 = new LinkedList<Integer>();
-
+		
+		ArrayDeque<Integer> q3 = new ArrayDeque<>(); // use deque as a queue
+		ArrayDeque<Integer> q5 = new ArrayDeque<>(); // use deque as a queue
+		ArrayDeque<Integer> q7 = new ArrayDeque<>(); // use deque as a queue
+		
 		q3.add(3);
 		q5.add(5);
 		q7.add(7);
+		
 		int val = 0;
 		for (int i = 1; i <= k; i++) {
 			int v3 = q3.peek();

src/chapter08/EightPoint1/Deck.java

@@ -1,12 +1,14 @@
 package chapter08.EightPoint1;
 
-import java.util.Queue;
+import java.util.ArrayDeque;
 import java.util.LinkedList;
 
 public class Deck <T extends Card> {
-	private Queue<T> deck;	// IMPORTANT: can't use a fixed size array[] since we are using generics.
+	
+	private ArrayDeque<T> deck;	// can't use a fixed size array[] since we are using generics.
+	
 	public Deck() {
-		deck = new LinkedList<T>();
+		deck = new ArrayDeque<T>();
 		initializeCards();
 	}
 

src/chapter18/Chapter18.java

@@ -1,7 +1,7 @@
 package chapter18;
 
 import java.util.Arrays;
-import java.util.LinkedList;
+import java.util.ArrayList;
 
 public class Chapter18 {
 	public static void main (String [] args) {
@@ -101,7 +101,7 @@ public static void test_EighteenPoint9() {
 	public static void test_EighteenPoint10() {
 		System.out.println("\n\n*** Test 18.10: Transform 1 word into another (changing 1 letter at a time)");
 		EighteenPoint10.setUpDict();
-		LinkedList<String> solution = EighteenPoint10.convert("Damp", "Like");
+		ArrayList<String> solution = EighteenPoint10.convert("Damp", "Like");
 		System.out.println(solution);
 	}
 

src/chapter18/EighteenPoint10.java

@@ -2,8 +2,9 @@
 
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.Queue;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+
 
 /* Tricks:
  * - Use BFS
@@ -25,23 +26,23 @@ public static void setUpDict() {
 	}
 
 	/* Uses BFS */
-	public static LinkedList<String> convert(String start, String end) {
+	public static ArrayList<String> convert(String start, String end) {
 		if (start == null || end == null || start.length() != end.length()) {
 			return null;
 		}
 
 		start = start.toUpperCase();
 		end   = end.toUpperCase();
 
-		Queue<String> queue                  = new LinkedList<>();
+		ArrayDeque<String> deque             = new ArrayDeque<>(); // use deque as a queue
 		HashSet<String> visited              = new HashSet<>();
 		HashMap<String, String> backtrackMap = new HashMap<>();
 
-		queue.add(start);
+		deque.add(start);
 		visited.add(start);
 
-		while (! queue.isEmpty()) {
-			String currWord = queue.remove();
+		while (! deque.isEmpty()) {
+			String currWord = deque.remove();
 			if (currWord.equals(end)) {
 				return buildSolution(backtrackMap, currWord);
 			}
@@ -50,7 +51,7 @@ public static LinkedList<String> convert(String start, String end) {
 				if ( ! visited.contains(neighbor)) {
 					visited.add(neighbor);
 					backtrackMap.put(neighbor, currWord);
-					queue.add(neighbor);
+					deque.add(neighbor);
 				}
 			}
 		}
@@ -75,8 +76,8 @@ private static HashSet<String> getNeighbors(String currString) {
 		return validWords;
 	}
 
-	private static LinkedList<String> buildSolution(HashMap<String, String> backtrackMap, String currWord) {
-		LinkedList<String> solution = new LinkedList<>();
+	private static ArrayList<String> buildSolution(HashMap<String, String> backtrackMap, String currWord) {
+		ArrayList<String> solution = new ArrayList<>();
 		solution.add(currWord);
 		while (backtrackMap.containsKey(currWord)) {
 			currWord = backtrackMap.get(currWord);