implement immutable linked list (untested)

Author: ymzong

src/section23/ImmutableList.java

@@ -1,7 +1,14 @@
 package section23;
 
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+import java.util.function.Function;
+
 /**
  * This class implements a generic immutable Linked List that demonstrates the advantages of immutable data structures.
+ *
+ * Despite that functional programming favors recursion, all recursions in this example are unwrapped to optimize perf.
  */
 public class ImmutableList<T> {
 
@@ -31,14 +38,14 @@ public ImmutableList(Node<T> head) {
         this.head = head;
     }
 
-    /* Prepends a value to the linked list, and returns a new immutable linked list */
+    /* Prepends a value to the linked list, and returns a new immutable linked list - O(1) */
     public ImmutableList<T> cons(T val) {
         Node<T> newHead = new Node<T>(val, head);
         ImmutableList<T> newList = new ImmutableList<>(newHead);
         return newList;
     }
 
-    /* Utility method that returns the length of linked list */
+    /* Utility method that returns the length of linked list - O(n) */
     public int length() {
         int result = 0;
         Node<T> iter = head;
@@ -50,24 +57,98 @@ public int length() {
         return result;
     }
 
-    /* Returns an element of the linked list by index */
+    /* Returns an element of the linked list by index - O(n) */
     public T get(int idx) {
         if (idx < 0) {
             throw new IndexOutOfBoundsException("negative index");
         }
 
-        return getFromNode(head, idx);
+        int steps = idx;
+        Node<T> iter = head;
+        while (steps > 0) {
+            if (iter == null) {
+                throw new IndexOutOfBoundsException("idx = " + idx);
+            }
+            iter = iter.next;
+            steps--;
+        }
+
+        if (iter == null) {
+            throw new IndexOutOfBoundsException("idx = " + idx);
+        }
+        return iter.data;
+    }
+
+    /* Applies a transformation function to all elements of the linked list and return a new immutable list */
+    public <W> ImmutableList<W> map(Function<T, W> fn) {
+        Stack<W> mappedValues = new Stack<>();
+        Node<T> iter = head;
+
+        while (iter != null) {
+            mappedValues.push(fn.apply(iter.data));
+        }
+
+        ImmutableList<W> result = new ImmutableList<>();
+        while (!mappedValues.isEmpty()) {
+            result = result.cons(mappedValues.pop());
+        }
+        return result;
+    }
+
+    /* Inserts an element to selected index and returns a new immutable list */
+    public ImmutableList<T> insert(T elem, int idx) {
+        if (idx < 0) {
+            throw new IndexOutOfBoundsException("negative index");
+        }
+
+        int steps = idx;
+        Node<T> iter = head;
+        Stack<T> prefix = new Stack<>();
+
+        while (steps > 0) {
+            if (iter == null) {
+                throw new IndexOutOfBoundsException("idx = " + idx);
+            }
+            prefix.push(iter.data);
+            iter = iter.next;
+            steps--;
+        }
+
+        // insert the element
+        ImmutableList<T> result = new ImmutableList<>(new Node<>(elem, iter));
+
+        // add in original prefix
+        while (!prefix.isEmpty()) {
+            result = result.cons(prefix.pop());
+        }
+
+        return result;
     }
 
-    /* Helper recursive method that returns the content of a node based on head and offset idx */
-    private static <T> T getFromNode(Node<T> head, int idx) {
-        if (head == null) {
-            throw new IndexOutOfBoundsException("index overflow");
+    /* Return a new immutable list that is the reverse of current list */
+    public ImmutableList<T> revert() {
+        ImmutableList<T> result = new ImmutableList<>();
+
+        Node<T> iter = head;
+        while (iter != null) {
+            result = result.cons(iter.data);
+            iter = iter.next;
         }
-        if (idx == 0) {
-            return head.data;
-        } else {
-            return getFromNode(head.next, idx - 1);
+
+        return result;
+    }
+
+    /* Returns a String representation of the linked list */
+    public String toString() {
+        StringBuilder resultBuffer = new StringBuilder("ImmutableList(");
+
+        Node<T> node = head;
+        while (node != null) {
+            resultBuffer.append(node.data);
+            resultBuffer.append(" - ");
         }
+
+        resultBuffer.delete(resultBuffer.length() - 3, resultBuffer.length()).append(")");
+        return resultBuffer.toString();
     }
-}
+}

src/section23/ImmutableListTest.java

@@ -0,0 +1,13 @@
+package section23;
+
+/**
+ * This class includes comprehensive tests for the immutable linked list in section23.ImmutableList.
+ * All core methods in ImmutableList are covered by the following tests.
+ */
+public class ImmutableListTest {
+
+    public static void main(String[] argv) {
+
+    }
+
+}