Google(R) Java Format(TM) everything

Author: cszach

src/main/lists/ArrayQueue.java

@@ -1,17 +1,16 @@
 /**
  * An implementation of queue using a static array.
  *
- * <p>
- * This implementation uses the cyclic buffer by storing the indices of the rear
- * and the front of the queue to achieve O(1) complexity on all operations.
+ * <p>This implementation uses the cyclic buffer by storing the indices of the rear and the front of
+ * the queue to achieve O(1) complexity on all operations.
  *
- * <p>
- * Operations and their time complexities are:
- *   <ul>
- *     <li><code>enqueue(T)</code>: O(1)</li>
- *     <li><code>dequeue()</code>: O(1)</li>
- *     <li><code>peek()</code>: O(1)</li>
- *   </ul>
+ * <p>Operations and their time complexities are:
+ *
+ * <ul>
+ *   <li><code>enqueue(T)</code>: O(1)
+ *   <li><code>dequeue()</code>: O(1)
+ *   <li><code>peek()</code>: O(1)
+ * </ul>
  */
 public class ArrayQueue<T> implements Queue<T> {
   Object[] array;
@@ -40,8 +39,7 @@ public boolean isEmpty() {
 
   @SuppressWarnings("unchecked")
   public T enqueue(T data) {
-    if (this.length == this.array.length)
-      return null;
+    if (this.length == this.array.length) return null;
 
     this.rearIndex = (this.rearIndex + 1) % this.array.length;
     this.array[this.rearIndex] = data;
@@ -52,8 +50,7 @@ public T enqueue(T data) {
 
   @SuppressWarnings("unchecked")
   public T dequeue() {
-    if (this.length == 0)
-      return null;
+    if (this.length == 0) return null;
 
     T dequeuedData = (T) this.array[this.frontIndex];
     this.array[this.frontIndex] = null;

src/main/lists/ArrayStack.java

@@ -1,14 +1,13 @@
 /**
  * An implementation of stack using static array.
  *
- * <p>
- * Operations with their time complexities are:
- *   <ul>
- *     <li><code>push(T)</code>: O(1)</li>
- *     <li><code>pop()</code>: O(1)</li>
- *     <li><code>peek()</code>: O(1)</li>
- *   </ul>
+ * <p>Operations with their time complexities are:
  *
+ * <ul>
+ *   <li><code>push(T)</code>: O(1)
+ *   <li><code>pop()</code>: O(1)
+ *   <li><code>peek()</code>: O(1)
+ * </ul>
  */
 public class ArrayStack<T> implements Stack<T> {
   Object[] array;
@@ -29,17 +28,15 @@ public int getCapacity() {
 
   @SuppressWarnings("unchecked")
   public T push(T data) {
-    if (this.length == this.array.length)
-      return null;
+    if (this.length == this.array.length) return null;
 
     this.array[this.length] = data;
     return (T) this.array[this.length++];
   }
 
   @SuppressWarnings("unchecked")
   public T pop() {
-    if (this.length == 0)
-      return null;
+    if (this.length == 0) return null;
 
     T poppedData = (T) this.array[--this.length];
     this.array[this.length] = null;

src/main/lists/DynamicArray.java

@@ -1,17 +1,17 @@
 /**
  * A dynamic array implementation based on a fixed-size array.
  *
- * <p>
- * Operations with their time complexities are:
- *   <ul>
- *     <li><code>shrinkCapacity()</code>: O(n)</li>
- *     <li><code>growCapacity()</code>: O(n)</li>
- *     <li><code>append(T)</code>: O(1)</li>
- *     <li><code>insert(T, int)</code>: O(n)</li>
- *     <li><code>remove()</code>: O(1)</li>
- *     <li><code>remove(int)</code>: O(n)</li>
- *     <li><code>get</code>: O(1)</li>
- *   </ul>
+ * <p>Operations with their time complexities are:
+ *
+ * <ul>
+ *   <li><code>shrinkCapacity()</code>: O(n)
+ *   <li><code>growCapacity()</code>: O(n)
+ *   <li><code>append(T)</code>: O(1)
+ *   <li><code>insert(T, int)</code>: O(n)
+ *   <li><code>remove()</code>: O(1)
+ *   <li><code>remove(int)</code>: O(n)
+ *   <li><code>get</code>: O(1)
+ * </ul>
  */
 public class DynamicArray<T> {
   Object[] array; // The underlying fixed-size array
@@ -38,8 +38,7 @@ public int getCapacity() {
   public DynamicArray<T> shrinkCapacity() {
     Object[] newArray = new Object[this.length];
 
-    for (int i = 0; i < this.length; i++)
-      newArray[i] = this.array[i];
+    for (int i = 0; i < this.length; i++) newArray[i] = this.array[i];
 
     this.array = newArray;
     return this;
@@ -48,27 +47,23 @@ public DynamicArray<T> shrinkCapacity() {
   public DynamicArray<T> growCapacity() {
     Object[] newArray = new Object[this.array.length * 2];
 
-    for (int i = 0; i < this.length; i++)
-      newArray[i] = this.array[i];
+    for (int i = 0; i < this.length; i++) newArray[i] = this.array[i];
 
     this.array = newArray;
     return this;
   }
 
   public DynamicArray<T> append(T data) {
-    if (this.length + 1 > this.array.length)
-      this.growCapacity();
+    if (this.length + 1 > this.array.length) this.growCapacity();
 
     this.array[this.length++] = data;
     return this;
   }
 
   public DynamicArray<T> insert(T data, int index) {
-    if (this.length + 1 > this.array.length)
-      this.growCapacity();
+    if (this.length + 1 > this.array.length) this.growCapacity();
 
-    for (int i = this.length++; i > index; i--)
-      this.array[i] = this.array[i - 1];
+    for (int i = this.length++; i > index; i--) this.array[i] = this.array[i - 1];
 
     this.array[index] = data;
     return this;
@@ -80,8 +75,7 @@ public DynamicArray<T> remove() {
   }
 
   public DynamicArray<T> remove(int index) {
-    for (int i = index + 1; i < this.length; i++)
-      this.array[i - 1] = this.array[i];
+    for (int i = index + 1; i < this.length; i++) this.array[i - 1] = this.array[i];
 
     return this.remove();
   }

src/main/lists/LinkedList.java

@@ -3,15 +3,15 @@
 /**
  * Simple linked list implementation.
  *
- * <p>
- * Operations with their complexities are:
- *   <ul>
- *     <li><code>get(int)</code>: O(n)</li>
- *     <li><code>insert(T, int)</code>: O(n)</li>
- *     <li><code>insertAtHead(T)</code>: O(1)</li>
- *     <li><code>delete(int)</code>: O(n)</li>
- *     <li><code>deleteAtHead()</code>: O(1)</li>
- *   </ul>
+ * <p>Operations with their complexities are:
+ *
+ * <ul>
+ *   <li><code>get(int)</code>: O(n)
+ *   <li><code>insert(T, int)</code>: O(n)
+ *   <li><code>insertAtHead(T)</code>: O(1)
+ *   <li><code>delete(int)</code>: O(n)
+ *   <li><code>deleteAtHead()</code>: O(1)
+ * </ul>
  */
 public class LinkedList<T> {
   LinkedNode<T> head;
@@ -48,25 +48,21 @@ public boolean isEmpty() {
   }
 
   public T get(int index) {
-    if (index < 0 || index >= this.length)
-      throw new IndexOutOfBoundsException();
+    if (index < 0 || index >= this.length) throw new IndexOutOfBoundsException();
 
     LinkedNode<T> node = this.head.next;
-    for (int i = 0; i < index; i++)
-      node = node.next;
+    for (int i = 0; i < index; i++) node = node.next;
 
     return node.data;
   }
 
   public LinkedNode<T> insert(T data, int index) {
-    if (index < 0 || index > this.length)
-      throw new IndexOutOfBoundsException();
+    if (index < 0 || index > this.length) throw new IndexOutOfBoundsException();
 
     LinkedNode<T> newNode = new LinkedNode<T>(data, null);
     LinkedNode<T> prevNode = this.head;
 
-    for (int i = 0; i < index; i++)
-      prevNode = prevNode.next;
+    for (int i = 0; i < index; i++) prevNode = prevNode.next;
 
     if (index != this.length) newNode.next = prevNode.next;
     prevNode.next = newNode;
@@ -84,13 +80,11 @@ public LinkedNode<T> insertAtHead(T data) {
   }
 
   public LinkedNode<T> delete(int index) {
-    if (index < 0 || index >= this.length)
-      throw new IndexOutOfBoundsException();
+    if (index < 0 || index >= this.length) throw new IndexOutOfBoundsException();
 
     LinkedNode<T> prevNode = this.head;
 
-    for (int i = 0; i < index; i++)
-      prevNode = prevNode.next;
+    for (int i = 0; i < index; i++) prevNode = prevNode.next;
 
     LinkedNode<T> deletedNode = prevNode.next;
     if (index != this.length) prevNode.next = deletedNode.next;

src/main/lists/LinkedListAlgorithms.java

@@ -1,10 +1,9 @@
 public class LinkedListAlgorithms {
   /**
-   * Detects the cycle, if exists, in a given linked list, using Floyd's
-   * turtoise and hare algorithm, or two-pointer technique.
+   * Detects the cycle, if exists, in a given linked list, using Floyd's turtoise and hare
+   * algorithm, or two-pointer technique.
    *
-   * <p>
-   * Runs in O(n) time and O(1) memory.
+   * <p>Runs in O(n) time and O(1) memory.
    *
    * @param list
    * @return The first node in the cycle.
@@ -35,25 +34,20 @@ public static <T> LinkedNode<T> detectCycle(LinkedList<T> list) {
   /**
    * Returns the intersection of two linked lists.
    *
-   * <p>
-   * Given lists A and B, first starts at the head of list B and travels to the
-   * end (the last node after the intersection), which we call <code>tail</code>.
-   * Then routes tail to A's head to form a cycle. Proceeds to use Floyd's
-   * turtoise and hare algorithm starting from B's head.
+   * <p>Given lists A and B, first starts at the head of list B and travels to the end (the last
+   * node after the intersection), which we call <code>tail</code>. Then routes tail to A's head to
+   * form a cycle. Proceeds to use Floyd's turtoise and hare algorithm starting from B's head.
+   *
+   * <p>Runs in linear time and constant memory.
    *
-   * <p>
-   * Runs in linear time and constant memory.
-   * 
    * @param listA
    * @param listB
-   * @return The intersection of two given lists, or <code>null</code> if there
-   * is no intersection.
+   * @return The intersection of two given lists, or <code>null</code> if there is no intersection.
    */
   public static <T> LinkedNode<T> getIntersection(LinkedList<T> listA, LinkedList<T> listB) {
     LinkedNode<T> tail = listB.getHead(); // The last node after the intersection (if exists)
 
-    while (tail.next != null)
-      tail = tail.next;
+    while (tail.next != null) tail = tail.next;
 
     tail.next = listA.getHead();
     LinkedNode<T> intersection = detectCycle(listB);
@@ -64,11 +58,11 @@ public static <T> LinkedNode<T> getIntersection(LinkedList<T> listA, LinkedList<
 
   /**
    * Reverse a given linked list in-place.
-   * 
+   *
    * @param list
    * @return The given linked list that has been reversed.
    */
-  public static<T> LinkedList<T> reverse(LinkedList<T> list) {
+  public static <T> LinkedList<T> reverse(LinkedList<T> list) {
     LinkedNode<T> next;
     LinkedNode<T> cur;
     LinkedNode<T> prev = list.getHead();

src/main/lists/LinkedQueue.java

@@ -1,20 +1,18 @@
 /**
  * An implementation of the queue data structure based on linked list.
  *
- * <p>
- * This implementation is basically a linked list with a tail, where the head
- * of the list is the front of the queue and the tail is the rear. Both the
- * front and the rear are empty nodes themselves. The last enqueued element
- * points to the rear and the rear points back to the element, forming a little
- * cycle. This helps achieve both enqueueing and dequeueing in constant time.
+ * <p>This implementation is basically a linked list with a tail, where the head of the list is the
+ * front of the queue and the tail is the rear. Both the front and the rear are empty nodes
+ * themselves. The last enqueued element points to the rear and the rear points back to the element,
+ * forming a little cycle. This helps achieve both enqueueing and dequeueing in constant time.
  *
- * <p>
- * Operations with their complexities are:
- *   <ul>
- *     <li><code>enqueue(T)</code>: O(1)</li>
- *     <li><code>dequeue()</code>: O(1)</li>
- *     <li><code>peek()</code>: O(1)</li>
- *   </ul>
+ * <p>Operations with their complexities are:
+ *
+ * <ul>
+ *   <li><code>enqueue(T)</code>: O(1)
+ *   <li><code>dequeue()</code>: O(1)
+ *   <li><code>peek()</code>: O(1)
+ * </ul>
  */
 public class LinkedQueue<T> implements Queue<T> {
   private LinkedNode<T> front; // head of linked list
@@ -44,8 +42,7 @@ public T enqueue(T data) {
   }
 
   public T dequeue() {
-    if (this.length == 0)
-      return null;
+    if (this.length == 0) return null;
 
     T dequeuedData = this.front.next.data;
     this.front.next = this.front.next.next;

src/main/lists/LinkedStack.java

@@ -1,17 +1,16 @@
 /**
  * An implementation of a stack based on a linked list.
  *
- * <p>
- * The head of the linked list is the top of the stack. All operations are O(1)
- * in time and space complexity.
+ * <p>The head of the linked list is the top of the stack. All operations are O(1) in time and space
+ * complexity.
  *
- * <p>
- * Operations with their time complexities are:
- *   <ul>
- *     <li><code>push(T)</code>: O(1)</li>
- *     <li><code>pop()</code>: O(1)</li>
- *     <li><code>peek()</code>: O(1)</li>
- *   </ul>
+ * <p>Operations with their time complexities are:
+ *
+ * <ul>
+ *   <li><code>push(T)</code>: O(1)
+ *   <li><code>pop()</code>: O(1)
+ *   <li><code>peek()</code>: O(1)
+ * </ul>
  */
 public class LinkedStack<T> implements Stack<T> {
   private LinkedNode<T> top;
@@ -38,8 +37,7 @@ public T push(T data) {
   }
 
   public T pop() {
-    if (this.length == 0)
-      return null;
+    if (this.length == 0) return null;
 
     T poppedData = this.top.next.data;
     this.top.next = this.top.next.next;

src/main/lists/Queue.java

@@ -1,5 +1,7 @@
 public interface Queue<T> {
   public T enqueue(T data);
+
   public T dequeue();
+
   public T peek();
 }

src/main/lists/Stack.java

@@ -1,5 +1,7 @@
 public interface Stack<T> {
   public T push(T data);
+
   public T pop();
+
   public T peek();
 }