easy peasy lemon squeezy

Author: ryanknj5

app/src/main/java/assignment/App.java

@@ -3,20 +3,67 @@
 public class App {
 
   public static int get(LinkedList list, int index) {
-    return 0;
-  }
+    LinkedList.Node item = list.head; // O(1)
+    for (int i = 0; i < index; i++) { // O(n)
+      item = item.next; // O(1)
+    }
+    return item.data; // O(1)
+  } // Algorithmic Complexity = O(n)
 
-  public static void set(LinkedList list, int index, int value) {}
+  public static void set(LinkedList list, int index, int value) {
+    LinkedList.Node item = list.head; // O(1)
+    for (int i = 0; i < index; i++) { // O(n)
+      item = item.next; // O(1)
+    }
+    item.data = value; // O(1)
+  } // Algorithmic Complexity = O(n)
 
-  public static void remove(LinkedList list, int index) {}
+  public static void remove(LinkedList list, int index) {
+
+    LinkedList.Node item = list.head; // O(1)
+    if (index == 0) { // O(1)
+      list.head = list.head.next; // O(1)
+    }
+    for (int i = 0; i < index - 1; i++) { // O(n)
+      item = item.next; // O(1)
+    }
+    if (item.next.next == null) { // O(1)
+      item.next = null; // O(1)
+    } else { // O(1)
+      item.next = item.next.next; // O(1)
+    }
+  } // Algorithmic Complexity = O(n)
 
   public static LinkedList reverse(LinkedList list) {
-    return list;
-  }
+    LinkedList reversedList = new LinkedList(); // O(1)
+    LinkedList.Node item = list.head; // O(1)
+
+    for (int i = 0; i < list.length(); i++) { // O(n)
+      reversedList.prepend(item.data); // O(1)
+      item = item.next; // O(1)
+    }
+    return reversedList; // O(1)
+  } // Algorithmic Complexity = O(n)
 
   public static boolean isSortedAscending(LinkedList list) {
-    return false;
-  }
+    LinkedList.Node item = list.head; // O(1)
+    while (item.next != null) { // O(n)
+      if (item.data < item.next.data) { // O(1)
+        item = item.next; // O(1)
+      } else { // O(1)
+        return false; // O(1)
+      }
+    }
+    return true; // O(1)
+  } // Algorithmic Complexity = O(n)
+
+  // Linked List practice
+  // Write .get
+  // Write .set
+  // Write method to delete index
+  // Reverse linked list
+  // Is linked list sorted?
+  // Find algorithmic complexity of each solution
 
   private App() {}
 }

app/src/test/java/assignment/AppTest.java

@@ -42,6 +42,18 @@ void testRemove() {
     assertEquals(3, list.head.next.data);
   }
 
+  @Test
+  void testRemoveIndex0() {
+    var list = new LinkedList();
+    list.append(1);
+    list.append(2);
+    list.append(3);
+    App.remove(list, 0);
+
+    assertEquals(2, list.head.data);
+    assertEquals(3, list.head.next.data);
+  }
+
   @Test
   void testReverse() {
     var list = new LinkedList();
@@ -50,6 +62,10 @@ void testReverse() {
     list.append(3);
     var reversed = App.reverse(list);
 
+    System.out.println(reversed.head.data);
+    System.out.println(reversed.head.next.data);
+    System.out.println(reversed.head.next.next.data);
+
     assertEquals(3, reversed.head.data);
     assertEquals(2, reversed.head.next.data);
     assertEquals(1, reversed.head.next.next.data);