Feedback

README.md

@@ -0,0 +1 @@
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/a1ZaAUA-)

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

@@ -3,20 +3,85 @@
 public class App {
 
   public static int get(LinkedList list, int index) {
-    return 0;
-  }
+    LinkedList.Node item = list.head; // O(1)
+    int length = list.length();
+    for (int i = 0; i < length; i++) { // O(n)
+      if (i == index) {
+        return item.data;
+      } // This would make it so that if index is in the bounds of length then it will return the
+      // data other wise return null right?
+      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)
+    int length = list.length();
+    for (int i = 0; i < length; i++) { // O(n)
+      if (i == index) {
+        item.data = value;
+      }
+      item = item.next; // 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)
+    // int length = list.length();
+    // for (int i = 0; i < length; i++) { // O(n)
+    //   reversedList.prepend(item.data); // O(1)
+    //   item = item.next; // O(1)
+    // }
+    // return reversedList; // O(1)
+    LinkedList.Node item = list.head; // O(1)
+    int length = list.length();
+    int counter = 0;
+    for (int i = 0; i < length; i++) { // O(n)
+      list.prepend(item.data); // O(1)
+      counter++;
+      remove(list, counter);
+      item = item.next; // O(1)
+    }
+    return list; // 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);