API and names update

Author: cszach

src/main/lists/ArrayQueue.java

@@ -8,16 +8,16 @@
  * <p>
  * Operations and their time complexities are:
  *   <ul>
- *     <li><code>enqueue</code>: O(1)</li>
- *     <li><code>dequeue</code>: O(1)</li>
- *     <li><code>peek</code>: O(1)</li>
+ *     <li><code>enqueue(T)</code>: O(1)</li>
+ *     <li><code>dequeue()</code>: O(1)</li>
+ *     <li><code>peek()</code>: O(1)</li>
  *   </ul>
  */
-public class ArrayQueue<T> {
-  private Object[] array;
-  private int length;
-  private int frontIndex;
-  private int rearIndex;
+public class ArrayQueue<T> implements Queue<T> {
+  Object[] array;
+  int length;
+  int frontIndex;
+  int rearIndex;
 
   public ArrayQueue(int capacity) {
     this.array = new Object[capacity];
@@ -34,26 +34,33 @@ public int getCapacity() {
     return this.array.length;
   }
 
-  public ArrayQueue<T> enqueue(T data) {
+  public boolean isEmpty() {
+    return this.length == 0;
+  }
+
+  @SuppressWarnings("unchecked")
+  public T enqueue(T data) {
     if (this.length == this.array.length)
-      return this;
+      return null;
 
     this.rearIndex = (this.rearIndex + 1) % this.array.length;
     this.array[this.rearIndex] = data;
 
     this.length++;
-    return this;
+    return (T) this.array[this.rearIndex];
   }
 
-  public ArrayQueue<T> dequeue() {
+  @SuppressWarnings("unchecked")
+  public T dequeue() {
     if (this.length == 0)
-      return this;
+      return null;
 
+    T dequeuedData = (T) this.array[this.frontIndex];
     this.array[this.frontIndex] = null;
     this.frontIndex = (this.frontIndex + 1) % this.array.length;
 
     this.length--;
-    return this;
+    return dequeuedData;
   }
 
   @SuppressWarnings("unchecked")

src/main/lists/ArrayStack.java

@@ -4,15 +4,15 @@
  * <p>
  * Operations with their time complexities are:
  *   <ul>
- *     <li><code>push</code>: O(1)</li>
- *     <li><code>pop</code>: O(1)</li>
- *     <li><code>peek</code>: O(1)</li>
+ *     <li><code>push(T)</code>: O(1)</li>
+ *     <li><code>pop()</code>: O(1)</li>
+ *     <li><code>peek()</code>: O(1)</li>
  *   </ul>
  *
  */
-public class ArrayStack<T> {
-  private Object[] array;
-  private int length;
+public class ArrayStack<T> implements Stack<T> {
+  Object[] array;
+  int length;
 
   public ArrayStack(int capacity) {
     this.array = new Object[capacity];
@@ -27,24 +27,27 @@ public int getCapacity() {
     return this.array.length;
   }
 
-  public ArrayStack<T> push(T data) {
+  @SuppressWarnings("unchecked")
+  public T push(T data) {
     if (this.length == this.array.length)
-      return this;
+      return null;
 
-    this.array[this.length++] = data;
-    return this;
+    this.array[this.length] = data;
+    return (T) this.array[this.length++];
   }
 
-  public ArrayStack<T> pop() {
+  @SuppressWarnings("unchecked")
+  public T pop() {
     if (this.length == 0)
-      return this;
+      return null;
 
-    this.array[--this.length] = null;
-    return this;
+    T poppedData = (T) this.array[--this.length];
+    this.array[this.length] = null;
+    return poppedData;
   }
 
   @SuppressWarnings("unchecked")
   public T peek() {
-    return (this.length == 0) ? null : (T) this.array[this.length - 1];
+    return (T) this.array[(this.length - 1) % (this.length + 1)];
   }
 }

src/main/lists/DynamicArray.java

@@ -4,18 +4,18 @@
  * <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</code>: O(1)</li>
- *     <li><code>insert</code>: O(n)</li>
- *     <li><code>remove</code> (at last element): O(1)</li>
- *     <li><code>remove</code> (at specified index): O(n)</li>
+ *     <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>
  */
 public class DynamicArray<T> {
-  private Object[] array; // The underlying fixed-size array
-  private int length; // The number of elements in this array
+  Object[] array; // The underlying fixed-size array
+  int length; // The number of elements in this array
 
   public DynamicArray() {
     this.array = new Object[10];

src/main/lists/LinkedList.java

@@ -6,21 +6,21 @@
  * <p>
  * Operations with their complexities are:
  *   <ul>
- *     <li><code>get</code>: O(n)</li>
- *     <li><code>insert</code>: O(n)</li>
- *     <li><code>insertAtHead</code>: O(1)</li>
- *     <li><code>delete</code>: O(n)</li>
- *     <li><code>deleteAtHead</code>: O(1)</li>
+ *     <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>
  */
 public class LinkedList<T> {
-  private LinkedListNode<T> head;
-  private int length;
+  LinkedNode<T> head;
+  int length;
 
   @SuppressWarnings("unchecked")
-  public static <T> T[] toArray(LinkedListNode<T> head, int length, Class<T> c) {
+  public static <T> T[] toArray(LinkedNode<T> head, int length, Class<T> c) {
     T[] array = (T[]) Array.newInstance(c, length);
-    LinkedListNode<T> node = head;
+    LinkedNode<T> node = head;
 
     for (int i = 0; i < length; i++) {
       node = node.next;
@@ -31,19 +31,11 @@ public static <T> T[] toArray(LinkedListNode<T> head, int length, Class<T> c) {
   }
 
   public LinkedList() {
-    this.head = new LinkedListNode<T>(null, null);
+    this.head = new LinkedNode<T>(null, null);
     this.length = 0;
   }
 
-  public LinkedList(T[] data) {
-    this.head = new LinkedListNode<T>(null, null);
-    this.length = 0;
-
-    for (T d: data)
-      this.insert(d, this.length);
-  }
-
-  public LinkedListNode<T> getHead() {
+  public LinkedNode<T> getHead() {
     return this.head.next;
   }
 
@@ -56,21 +48,22 @@ public boolean isEmpty() {
   }
 
   public T get(int index) {
-    if (index < 0 || index >= this.length) throw new IndexOutOfBoundsException();
-
-    LinkedListNode<T> node = this.head.next;
+    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;
 
     return node.data;
   }
 
-  public LinkedListNode<T> insert(T data, int index) {
-    if (index < 0 || index > this.length) throw new IndexOutOfBoundsException();
+  public LinkedNode<T> insert(T data, int index) {
+    if (index < 0 || index > this.length)
+      throw new IndexOutOfBoundsException();
 
-    LinkedListNode<T> newNode = new LinkedListNode<T>(data, null);
-    LinkedListNode<T> prevNode = this.head;
+    LinkedNode<T> newNode = new LinkedNode<T>(data, null);
+    LinkedNode<T> prevNode = this.head;
 
     for (int i = 0; i < index; i++)
       prevNode = prevNode.next;
@@ -82,32 +75,33 @@ public LinkedListNode<T> insert(T data, int index) {
     return newNode;
   }
 
-  public LinkedListNode<T> insertAtHead(T data) {
-    LinkedListNode<T> newNode = new LinkedListNode<T>(data, this.head.next);
+  public LinkedNode<T> insertAtHead(T data) {
+    LinkedNode<T> newNode = new LinkedNode<T>(data, this.head.next);
     this.head.next = newNode;
 
     this.length++;
     return newNode;
   }
 
-  public LinkedListNode<T> delete(int index) {
-    if (index < 0 || index >= this.length) throw new IndexOutOfBoundsException();
+  public LinkedNode<T> delete(int index) {
+    if (index < 0 || index >= this.length)
+      throw new IndexOutOfBoundsException();
 
-    LinkedListNode<T> prevNode = this.head;
+    LinkedNode<T> prevNode = this.head;
 
     for (int i = 0; i < index; i++)
       prevNode = prevNode.next;
 
-    LinkedListNode<T> deletedNode = prevNode.next;
+    LinkedNode<T> deletedNode = prevNode.next;
     if (index != this.length) prevNode.next = deletedNode.next;
 
     this.length--;
     return deletedNode;
   }
 
-  public LinkedListNode<T> deleteAtHead() {
+  public LinkedNode<T> deleteAtHead() {
     if (this.head.next != null) {
-      LinkedListNode<T> deletedNode = this.head.next;
+      LinkedNode<T> deletedNode = this.head.next;
       this.head.next = this.head.next.next;
 
       this.length--;

src/main/lists/LinkedListAlgorithms.java

@@ -9,16 +9,16 @@ public class LinkedListAlgorithms {
    * @param list
    * @return The first node in the cycle.
    */
-  public static <T> LinkedListNode<T> detectCycle(LinkedList<T> list) {
-    LinkedListNode<T> rabbit = list.getHead();
-    LinkedListNode<T> turtle = list.getHead();
+  public static <T> LinkedNode<T> detectCycle(LinkedList<T> list) {
+    LinkedNode<T> rabbit = list.getHead();
+    LinkedNode<T> turtle = list.getHead();
 
     while (rabbit != null && rabbit.next != null) {
       rabbit = rabbit.next.next;
       turtle = turtle.next;
 
       if (rabbit == turtle) {
-        LinkedListNode<T> bear = list.getHead();
+        LinkedNode<T> bear = list.getHead();
 
         while (bear != rabbit) {
           bear = bear.next;
@@ -49,16 +49,28 @@ public static <T> LinkedListNode<T> detectCycle(LinkedList<T> list) {
    * @return The intersection of two given lists, or <code>null</code> if there
    * is no intersection.
    */
-  public static <T> LinkedListNode<T> getIntersection(LinkedList<T> listA, LinkedList<T> listB) {
-    LinkedListNode<T> tail = listB.getHead(); // The last node after the intersection (if exists)
+  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;
 
     tail.next = listA.getHead();
-    LinkedListNode<T> intersection = detectCycle(listB);
+    LinkedNode<T> intersection = detectCycle(listB);
 
     tail.next = null;
     return intersection;
   }
+
+  /**
+   * 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) {
+    LinkedNode<T> next;
+    LinkedNode<T> cur;
+    LinkedNode<T> prev = list.getHead();
+  }
 }

src/main/lists/LinkedListNode.java

@@ -0,0 +1,9 @@
+class LinkedNode<T> {
+  public T data;
+  protected LinkedNode<T> next;
+
+  protected LinkedNode(T data, LinkedNode<T> next) {
+    this.data = data;
+    this.next = next;
+  }
+}