From beaa27307a8a2313b2ceb9e22821c74d3c54b599 Mon Sep 17 00:00:00 2001
From: eveline0205 <evelinegabriela7@gmail.com>
Date: Thu, 20 Feb 2020 22:44:00 -0800
Subject: [PATCH 1/5] Tugas Struktur Data

---
 assignment-01/H071181317/Main.java            |  23 +
 assignment-01/H071181317/Node.java            |  24 +
 .../H071181317/SingleLinkedList.java          | 650 ++++++++++++++++++
 3 files changed, 697 insertions(+)
 create mode 100644 assignment-01/H071181317/Main.java
 create mode 100644 assignment-01/H071181317/Node.java
 create mode 100644 assignment-01/H071181317/SingleLinkedList.java

diff --git a/assignment-01/H071181317/Main.java b/assignment-01/H071181317/Main.java
new file mode 100644
index 0000000..31a4c53
--- /dev/null
+++ b/assignment-01/H071181317/Main.java
@@ -0,0 +1,23 @@
+public class Main {
+    public static void main(String[] args) {
+        SingleLinkedList<String> str = new SingleLinkedList<>();
+        SingleLinkedList<String> str2 = new SingleLinkedList<>();
+	SingleLinkedList<Integer> integer = new SingleLinkedList<Integer>();	
+
+        str.isEmpty();
+        str.traverse();
+        str.append("1");
+        str.append("2");
+        str.append("3");
+        str.append("4");
+        str.append("5");
+        str2.append("data1");
+        str.mergeAppend(str2);
+        str.traverse();
+        str.indexOf("data1");
+        str.prependBeforeIndex("6", 0);
+        str.traverse();
+
+    }
+
+}
\ No newline at end of file
diff --git a/assignment-01/H071181317/Node.java b/assignment-01/H071181317/Node.java
new file mode 100644
index 0000000..d2b443f
--- /dev/null
+++ b/assignment-01/H071181317/Node.java
@@ -0,0 +1,24 @@
+public class Node<T> {
+    private T data;
+    private Node<T> pointer;
+
+    public Node(T data) {
+        this.data = data;
+    }
+
+    public Node<T> getPointer() {
+        return pointer;
+    }
+
+    public void setPointer(Node<T> pointer) {
+        this.pointer = pointer;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    public boolean hasPointer() {
+        return pointer != null;
+    }
+}
diff --git a/assignment-01/H071181317/SingleLinkedList.java b/assignment-01/H071181317/SingleLinkedList.java
new file mode 100644
index 0000000..c0bbc28
--- /dev/null
+++ b/assignment-01/H071181317/SingleLinkedList.java
@@ -0,0 +1,650 @@
+import java.util.NoSuchElementException;
+
+public class SingleLinkedList<T> {
+    private Node<T> head;
+    private Node<T> tail;
+    private int size;
+
+    public void append(T data) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = new Node<T>(data);
+            head.setPointer(tail);
+            size++;
+            return;
+        }
+        Node<T> newNode = new Node<T>(data);
+        tail.setPointer(newNode);
+        tail = newNode;
+        size++;
+    }
+
+    public void appendAfterData(T data, T after) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = new Node<T>(data);
+            head.setPointer(tail);
+            size++;
+            return;
+        }
+
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(data);
+
+        while (node.getPointer() != null) {
+            if (node.getData() == after) {
+                newNode.setPointer(node.getPointer());
+                node.setPointer(newNode);
+                size++;
+                return;
+            }
+            if (tail.getData() == after || node.getData() != after) {
+                append(data);
+                size++;
+                return;
+            }
+            node = node.getPointer();
+        }
+    }
+
+    public void appendAfterIndex(T data, int index) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = new Node<T>(data);
+            head.setPointer(tail);
+            size++;
+            return;
+        }
+
+        int pos = 0;
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(data);
+
+        while (node.getPointer() != null) {
+            if (pos == index) {
+                newNode.setPointer(node.getPointer());
+                node.setPointer(newNode);
+                size++;
+                return;
+            }
+            pos++;
+            node = node.getPointer();
+        }
+        if ((size - 1) == index || pos != index) {
+            append(data);
+            size++;
+            return;
+        }
+    }
+
+    public void appendVarargs(T... datas) {
+        for (T data : datas) {
+            append(data);
+            size++;
+        }
+    }
+
+    public void prependVarargs(T... datas) {
+        for (T data : datas) {
+            prepend(data);
+            size++;
+        }
+    }
+
+    public void mergeAppend(SingleLinkedList<T> list) {
+        tail.setPointer(list.head);
+        tail = list.tail;
+        size += list.size;
+        return;
+    }
+
+    public void mergePrepend(SingleLinkedList<T> list) {
+        head = list.head;
+        list.tail.setPointer(list.head);
+        size += list.size;
+        return;
+    }
+
+    public void prepend(T data) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+
+        if (tail == null) {
+            tail = head;
+            Node<T> newNode = new Node<T>(data);
+            newNode.setPointer(tail);
+            head = newNode;
+            size++;
+            return;
+        }
+        Node<T> newNode = new Node<T>(data);
+        newNode.setPointer(head);
+        head = newNode;
+        size++;
+    }
+
+    public void prependBeforeData(T data, T before) {
+        Node<T> newNode = new Node<T>(data);
+
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = head;
+            newNode.setPointer(tail);
+            head = newNode;
+            size++;
+            return;
+        }
+
+        Node<T> node = head;
+
+        while (node.getPointer().getPointer() != null) {
+            if (node.getPointer().getData() == before) {
+                newNode.setPointer(node.getPointer());
+                node.setPointer(newNode);
+                size++;
+                return;
+            }
+            if (node.getData() == before || node.getData() != before) {
+                prepend(data);
+                size++;
+                return;
+            }
+            node = node.getPointer();
+        }
+    }
+
+    public void prependBeforeIndex(T data, int index) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = new Node<T>(data);
+            head.setPointer(tail);
+            size++;
+            return;
+        }
+
+        int pos = 0;
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(data);
+
+        while (node.getPointer().getPointer() != null) {
+            if ((pos + 1) == index) {
+                newNode.setPointer(node.getPointer());
+                node.setPointer(newNode);
+                size++;
+                return;
+            }
+            if (0 == index || pos != index) {
+                prepend(data);
+                size++;
+                return;
+            }
+            node = node.getPointer();
+            pos++;
+        }
+    }
+
+    public void removeByData(T data) {
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            if (node.getPointer().getData() == data) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            if (node.getData() == data) {
+                removeHead();
+            }
+            node = node.getPointer();
+        }
+        if (tail.getData() == data) {
+            removeTail();
+        }
+    }
+
+    public void removeByIndex(int index) {
+        int pos = 0;
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            if (index - pos == 1) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            pos++;
+            node = node.getPointer();
+        }
+        if (0 == index) {
+            removeHead();
+        }
+        if (size == index) {
+            removeTail();
+        }
+        if ((size - 1) < index) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+    public void removeAfterData(T data) {
+        Node<T> node = head;
+        while (node.getPointer() != null) {
+            if (node.getData() == data) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            node = node.getPointer();
+        }
+        if (node.getPointer() == tail) {
+            node.setPointer(null);
+            tail = node;
+        }
+    }
+
+    public void removeAfterIndex(int index) {
+        int pos = 0;
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            if (pos == index) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            pos++;
+            node = node.getPointer();
+        }
+        if (size - index == 2) {
+            removeTail();
+        }
+        if ((size - 1) < index) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+    public void removeBeforeData(T data) {
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            if (node.getData() == data) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            node = node.getPointer();
+        }
+        if (head.getData() == data) {
+            removeHead();
+        }
+    }
+
+    public void removeBeforeIndex(int index) {
+        Node<T> node = head;
+        int pos = 0;
+
+        if ((pos + 1) == index) {
+            head = head.getPointer();
+            size--;
+            return;
+        }
+        while (node.getPointer() != null) {
+            if ((index) - pos == 2) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            node = node.getPointer();
+            pos++;
+        }
+        throw new IndexOutOfBoundsException("Index Out Of Bounds");
+    }
+
+    public void removeHead() {
+        if (head == null) {
+            throw new NoSuchElementException("Empty List");
+        }
+        head = head.getPointer();
+        size--;
+    }
+
+    public void removeTail() {
+        if (head == null) {
+            throw new NoSuchElementException("Empty List");
+        } else if (tail == null) {
+            throw new NoSuchElementException("Head");
+        } else if (tail == head) {
+            throw new NoSuchElementException("Head is Tail");
+        }
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            node = node.getPointer();
+        }
+        node.setPointer(null);
+        tail = node;
+        size--;
+    }
+
+    public void removeForwardData(T data) {
+        Node<T> node = head;
+        int count = 0;
+        try {
+            while (node.getData() != data) {
+                node = node.getPointer();
+                count++;
+            }
+            node.setPointer(null);
+            size = count + 1;
+        } catch (Exception e) {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public void removeForwardIndex(int index) {
+        Node<T> node = head;
+        int pos = 0;
+        int count = 0;
+        try {
+            while (pos != index) {
+                node = node.getPointer();
+                count++;
+                pos++;
+            }
+            node.setPointer(null);
+            size = count + 1;
+        } catch (Exception e) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+    public void removeBackwardData(T data) {
+        Node<T> node = head;
+        int count = 0;
+        try {
+            while (node.getData() != data) {
+                node = node.getPointer();
+                count++;
+            }
+            head = node;
+            size -= count;
+        } catch (Exception e) {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public void removeBackwardIndex(int index) {
+        int pos = 0;
+        int count = 0;
+        Node<T> node = head;
+        try {
+            while (pos != index) {
+                node = node.getPointer();
+                count++;
+                pos++;
+            }
+            head = node;
+            size -= count;
+        } catch (Exception e) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+    public void describeNodeData(T data) {
+        if (head == null) {
+            throw new NoSuchElementException("Empty List");
+        }
+        if (head.getData() == data) {
+            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", head.getData(), 0);
+            return;
+        }
+        if (tail.getData() == data) {
+            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", tail.getData(), size - 1);
+            return;
+        }
+        Node<T> node = head;
+        int index = 0;
+        while (node.hasPointer()) {
+            if (node.getData() == data) {
+                System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", node.getData(), index);
+                return;
+            }
+            node = node.getPointer();
+            index++;
+        }
+        throw new NoSuchElementException("No Such Element");
+    }
+
+    public void describeNodeIndex(int index) {
+        if (head == null) {
+            throw new NoSuchElementException("Empty List");
+        }
+        if (0 == index) {
+            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", head.getData(), 0);
+            return;
+        }
+        if ((size - 1) == index) {
+            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", tail.getData(), size - 1);
+            return;
+        }
+        Node<T> node = head;
+        int pos = 0;
+        while (node.hasPointer()) {
+            if (pos == index) {
+                System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", node.getData(), pos);
+                return;
+            }
+            node = node.getPointer();
+            pos++;
+        }
+        throw new NoSuchElementException("No Such Element");
+    }
+
+    public int indexOf(T data) {
+        int pos = 0;
+        Node<T> node = head;
+
+        while (node.getPointer() != null) {
+            pos++;
+            node = node.getPointer();
+            if (node.getData() == data) {
+                System.out.printf("indeks => %s\n", pos);
+                return pos;
+            }
+        }
+        throw new NoSuchElementException("No Such Element");
+    }
+
+    public boolean isEmpty() {
+        if (size == 0) {
+            System.out.println("List is Empty");
+            return true;
+        }
+        System.out.println("List is filled");
+        return false;
+    }
+
+    public void unique() {
+    }
+
+    public void sort() {
+    }
+
+    public void updateByData(T data, T newData) {
+        if (head == null)
+            throw new NoSuchElementException("Empty List");
+
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(newData);
+
+        if (node.getData() == data) {
+            head = newNode;
+            newNode.setPointer(node.getPointer());
+            node.setPointer(null);
+            return;
+        }
+        while (node.getPointer().getPointer() != null) {
+            if (node.getPointer().getData() == data) {
+                newNode.setPointer(node.getPointer().getPointer());
+                node.setPointer(newNode);
+                return;
+            }
+            node = node.getPointer();
+        }
+        if (tail.getData() == data) {
+            newNode.setPointer(null);
+            node.setPointer(newNode);
+            tail = newNode;
+            return;
+        }
+        if (node.getPointer().getData() != data) {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public void updateByIndex(int index, T newData) {
+        if (head == null)
+            throw new NoSuchElementException("Empty List");
+
+        int pos = 0;
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(newData);
+
+        if (0 == index) {
+            head = newNode;
+            newNode.setPointer(node.getPointer());
+            node.setPointer(null);
+            return;
+        }
+        while (node.getPointer().getPointer() != null) {
+            if (index - pos == 1) {
+                newNode.setPointer(node.getPointer().getPointer());
+                node.setPointer(newNode);
+                return;
+            }
+            pos++;
+            node = node.getPointer();
+        }
+        if ((size - 1) == index) {
+            newNode.setPointer(null);
+            node.setPointer(newNode);
+            tail = newNode;
+            return;
+        }
+        if ((size - 1) < index)
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+    }
+
+    public void clear() {
+        head = null;
+        size = 0;
+    }
+
+    public void traverse() {
+        if (head == null) {
+            System.out.println("Empty Linked List");
+            return;
+        }
+        Node<T> node = head;
+        while (node.hasPointer()) {
+            System.out.printf("[%s] -> ", node.getData());
+            node = node.getPointer();
+        }
+        System.out.printf("[%s] -> null\n", node.getData());
+    }
+
+    public boolean contain(T data) {
+        Node<T> node = head;
+        while (node.getPointer() != null) {
+            node = node.getPointer();
+        }
+        if (node.getData() == data) {
+            System.out.println("Data is true");
+            return true;
+        } else {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public T get(int index) {
+        Node<T> node = head;
+        int pos = 0;
+        while (node.getPointer() != null) {
+            if (pos == index) {
+                System.out.printf("data => [%s]\n", node.getData());
+                return node.getData();
+            }
+            node = node.getPointer();
+            pos++;
+        }
+        if (size - 1 == index) {
+            System.out.printf("data => [%s]\n", node.getData());
+            return node.getData();
+        }
+        throw new IndexOutOfBoundsException("Index Out Of Bounds");
+    }
+
+    public int size() {
+        System.out.println("Size ::> " + size);
+        return size;
+    }
+
+    public void traverseFromData(T data) {
+        try {
+            if (head == null) {
+                System.out.println("Empty Linked List");
+                return;
+            }
+            Node<T> node = head;
+            while (node.getData() != data) {
+                node = node.getPointer();
+            }
+            while (node.getPointer() != null) {
+                System.out.printf("[%s] -> ", node.getData());
+                node = node.getPointer();
+            }
+            System.out.printf("[%s] -> null\n", node.getData());
+        } catch (Exception E) {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public void traverseFromIndex(int index) {
+        Node<T> node = head;
+        int pos = 0;
+        while (node.getPointer().getPointer() != null) {
+            pos++;
+            node = node.getPointer();
+        }
+        if (pos == index) {
+            while (node.getPointer() != null) {
+                System.out.printf("[%s] -> ", node.getData());
+                node = node.getPointer();
+            }
+            System.out.printf("[%s] -> null\n", node.getData());
+            return;
+        }
+        if (pos != index) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+}

From 1604c305ee9a19656db09466681ffe83dbceb7e1 Mon Sep 17 00:00:00 2001
From: Eveline Gabriela Winarto <56248995+eveline0205@users.noreply.github.com>
Date: Thu, 20 Feb 2020 22:51:54 -0800
Subject: [PATCH 2/5] Delete Node.java

---
 assignment-01/H071181317/Node.java | 24 ------------------------
 1 file changed, 24 deletions(-)
 delete mode 100644 assignment-01/H071181317/Node.java

diff --git a/assignment-01/H071181317/Node.java b/assignment-01/H071181317/Node.java
deleted file mode 100644
index d2b443f..0000000
--- a/assignment-01/H071181317/Node.java
+++ /dev/null
@@ -1,24 +0,0 @@
-public class Node<T> {
-    private T data;
-    private Node<T> pointer;
-
-    public Node(T data) {
-        this.data = data;
-    }
-
-    public Node<T> getPointer() {
-        return pointer;
-    }
-
-    public void setPointer(Node<T> pointer) {
-        this.pointer = pointer;
-    }
-
-    public T getData() {
-        return data;
-    }
-
-    public boolean hasPointer() {
-        return pointer != null;
-    }
-}

From 6b645bea364ef11d37c148da68b26089a2aa360d Mon Sep 17 00:00:00 2001
From: Eveline Gabriela Winarto <56248995+eveline0205@users.noreply.github.com>
Date: Thu, 20 Feb 2020 22:52:09 -0800
Subject: [PATCH 3/5] Delete Main.java

---
 assignment-01/H071181317/Main.java | 23 -----------------------
 1 file changed, 23 deletions(-)
 delete mode 100644 assignment-01/H071181317/Main.java

diff --git a/assignment-01/H071181317/Main.java b/assignment-01/H071181317/Main.java
deleted file mode 100644
index 31a4c53..0000000
--- a/assignment-01/H071181317/Main.java
+++ /dev/null
@@ -1,23 +0,0 @@
-public class Main {
-    public static void main(String[] args) {
-        SingleLinkedList<String> str = new SingleLinkedList<>();
-        SingleLinkedList<String> str2 = new SingleLinkedList<>();
-	SingleLinkedList<Integer> integer = new SingleLinkedList<Integer>();	
-
-        str.isEmpty();
-        str.traverse();
-        str.append("1");
-        str.append("2");
-        str.append("3");
-        str.append("4");
-        str.append("5");
-        str2.append("data1");
-        str.mergeAppend(str2);
-        str.traverse();
-        str.indexOf("data1");
-        str.prependBeforeIndex("6", 0);
-        str.traverse();
-
-    }
-
-}
\ No newline at end of file

From 6026e9b387fdec805951a5ecc6672c7720f3d724 Mon Sep 17 00:00:00 2001
From: Eveline Gabriela Winarto <56248995+eveline0205@users.noreply.github.com>
Date: Thu, 20 Feb 2020 22:52:31 -0800
Subject: [PATCH 4/5] Delete SingleLinkedList.java

---
 .../H071181317/SingleLinkedList.java          | 650 ------------------
 1 file changed, 650 deletions(-)
 delete mode 100644 assignment-01/H071181317/SingleLinkedList.java

diff --git a/assignment-01/H071181317/SingleLinkedList.java b/assignment-01/H071181317/SingleLinkedList.java
deleted file mode 100644
index c0bbc28..0000000
--- a/assignment-01/H071181317/SingleLinkedList.java
+++ /dev/null
@@ -1,650 +0,0 @@
-import java.util.NoSuchElementException;
-
-public class SingleLinkedList<T> {
-    private Node<T> head;
-    private Node<T> tail;
-    private int size;
-
-    public void append(T data) {
-        if (head == null) {
-            head = new Node<T>(data);
-            size++;
-            return;
-        }
-        if (tail == null) {
-            tail = new Node<T>(data);
-            head.setPointer(tail);
-            size++;
-            return;
-        }
-        Node<T> newNode = new Node<T>(data);
-        tail.setPointer(newNode);
-        tail = newNode;
-        size++;
-    }
-
-    public void appendAfterData(T data, T after) {
-        if (head == null) {
-            head = new Node<T>(data);
-            size++;
-            return;
-        }
-        if (tail == null) {
-            tail = new Node<T>(data);
-            head.setPointer(tail);
-            size++;
-            return;
-        }
-
-        Node<T> node = head;
-        Node<T> newNode = new Node<T>(data);
-
-        while (node.getPointer() != null) {
-            if (node.getData() == after) {
-                newNode.setPointer(node.getPointer());
-                node.setPointer(newNode);
-                size++;
-                return;
-            }
-            if (tail.getData() == after || node.getData() != after) {
-                append(data);
-                size++;
-                return;
-            }
-            node = node.getPointer();
-        }
-    }
-
-    public void appendAfterIndex(T data, int index) {
-        if (head == null) {
-            head = new Node<T>(data);
-            size++;
-            return;
-        }
-        if (tail == null) {
-            tail = new Node<T>(data);
-            head.setPointer(tail);
-            size++;
-            return;
-        }
-
-        int pos = 0;
-        Node<T> node = head;
-        Node<T> newNode = new Node<T>(data);
-
-        while (node.getPointer() != null) {
-            if (pos == index) {
-                newNode.setPointer(node.getPointer());
-                node.setPointer(newNode);
-                size++;
-                return;
-            }
-            pos++;
-            node = node.getPointer();
-        }
-        if ((size - 1) == index || pos != index) {
-            append(data);
-            size++;
-            return;
-        }
-    }
-
-    public void appendVarargs(T... datas) {
-        for (T data : datas) {
-            append(data);
-            size++;
-        }
-    }
-
-    public void prependVarargs(T... datas) {
-        for (T data : datas) {
-            prepend(data);
-            size++;
-        }
-    }
-
-    public void mergeAppend(SingleLinkedList<T> list) {
-        tail.setPointer(list.head);
-        tail = list.tail;
-        size += list.size;
-        return;
-    }
-
-    public void mergePrepend(SingleLinkedList<T> list) {
-        head = list.head;
-        list.tail.setPointer(list.head);
-        size += list.size;
-        return;
-    }
-
-    public void prepend(T data) {
-        if (head == null) {
-            head = new Node<T>(data);
-            size++;
-            return;
-        }
-
-        if (tail == null) {
-            tail = head;
-            Node<T> newNode = new Node<T>(data);
-            newNode.setPointer(tail);
-            head = newNode;
-            size++;
-            return;
-        }
-        Node<T> newNode = new Node<T>(data);
-        newNode.setPointer(head);
-        head = newNode;
-        size++;
-    }
-
-    public void prependBeforeData(T data, T before) {
-        Node<T> newNode = new Node<T>(data);
-
-        if (head == null) {
-            head = new Node<T>(data);
-            size++;
-            return;
-        }
-        if (tail == null) {
-            tail = head;
-            newNode.setPointer(tail);
-            head = newNode;
-            size++;
-            return;
-        }
-
-        Node<T> node = head;
-
-        while (node.getPointer().getPointer() != null) {
-            if (node.getPointer().getData() == before) {
-                newNode.setPointer(node.getPointer());
-                node.setPointer(newNode);
-                size++;
-                return;
-            }
-            if (node.getData() == before || node.getData() != before) {
-                prepend(data);
-                size++;
-                return;
-            }
-            node = node.getPointer();
-        }
-    }
-
-    public void prependBeforeIndex(T data, int index) {
-        if (head == null) {
-            head = new Node<T>(data);
-            size++;
-            return;
-        }
-        if (tail == null) {
-            tail = new Node<T>(data);
-            head.setPointer(tail);
-            size++;
-            return;
-        }
-
-        int pos = 0;
-        Node<T> node = head;
-        Node<T> newNode = new Node<T>(data);
-
-        while (node.getPointer().getPointer() != null) {
-            if ((pos + 1) == index) {
-                newNode.setPointer(node.getPointer());
-                node.setPointer(newNode);
-                size++;
-                return;
-            }
-            if (0 == index || pos != index) {
-                prepend(data);
-                size++;
-                return;
-            }
-            node = node.getPointer();
-            pos++;
-        }
-    }
-
-    public void removeByData(T data) {
-        Node<T> node = head;
-        while (node.getPointer().getPointer() != null) {
-            if (node.getPointer().getData() == data) {
-                node.setPointer(node.getPointer().getPointer());
-                size--;
-                return;
-            }
-            if (node.getData() == data) {
-                removeHead();
-            }
-            node = node.getPointer();
-        }
-        if (tail.getData() == data) {
-            removeTail();
-        }
-    }
-
-    public void removeByIndex(int index) {
-        int pos = 0;
-        Node<T> node = head;
-        while (node.getPointer().getPointer() != null) {
-            if (index - pos == 1) {
-                node.setPointer(node.getPointer().getPointer());
-                size--;
-                return;
-            }
-            pos++;
-            node = node.getPointer();
-        }
-        if (0 == index) {
-            removeHead();
-        }
-        if (size == index) {
-            removeTail();
-        }
-        if ((size - 1) < index) {
-            throw new IndexOutOfBoundsException("Index Out Of Bounds");
-        }
-    }
-
-    public void removeAfterData(T data) {
-        Node<T> node = head;
-        while (node.getPointer() != null) {
-            if (node.getData() == data) {
-                node.setPointer(node.getPointer().getPointer());
-                size--;
-                return;
-            }
-            node = node.getPointer();
-        }
-        if (node.getPointer() == tail) {
-            node.setPointer(null);
-            tail = node;
-        }
-    }
-
-    public void removeAfterIndex(int index) {
-        int pos = 0;
-        Node<T> node = head;
-        while (node.getPointer().getPointer() != null) {
-            if (pos == index) {
-                node.setPointer(node.getPointer().getPointer());
-                size--;
-                return;
-            }
-            pos++;
-            node = node.getPointer();
-        }
-        if (size - index == 2) {
-            removeTail();
-        }
-        if ((size - 1) < index) {
-            throw new IndexOutOfBoundsException("Index Out Of Bounds");
-        }
-    }
-
-    public void removeBeforeData(T data) {
-        Node<T> node = head;
-        while (node.getPointer().getPointer() != null) {
-            if (node.getData() == data) {
-                node.setPointer(node.getPointer().getPointer());
-                size--;
-                return;
-            }
-            node = node.getPointer();
-        }
-        if (head.getData() == data) {
-            removeHead();
-        }
-    }
-
-    public void removeBeforeIndex(int index) {
-        Node<T> node = head;
-        int pos = 0;
-
-        if ((pos + 1) == index) {
-            head = head.getPointer();
-            size--;
-            return;
-        }
-        while (node.getPointer() != null) {
-            if ((index) - pos == 2) {
-                node.setPointer(node.getPointer().getPointer());
-                size--;
-                return;
-            }
-            node = node.getPointer();
-            pos++;
-        }
-        throw new IndexOutOfBoundsException("Index Out Of Bounds");
-    }
-
-    public void removeHead() {
-        if (head == null) {
-            throw new NoSuchElementException("Empty List");
-        }
-        head = head.getPointer();
-        size--;
-    }
-
-    public void removeTail() {
-        if (head == null) {
-            throw new NoSuchElementException("Empty List");
-        } else if (tail == null) {
-            throw new NoSuchElementException("Head");
-        } else if (tail == head) {
-            throw new NoSuchElementException("Head is Tail");
-        }
-        Node<T> node = head;
-        while (node.getPointer().getPointer() != null) {
-            node = node.getPointer();
-        }
-        node.setPointer(null);
-        tail = node;
-        size--;
-    }
-
-    public void removeForwardData(T data) {
-        Node<T> node = head;
-        int count = 0;
-        try {
-            while (node.getData() != data) {
-                node = node.getPointer();
-                count++;
-            }
-            node.setPointer(null);
-            size = count + 1;
-        } catch (Exception e) {
-            throw new NoSuchElementException("No Such Element");
-        }
-    }
-
-    public void removeForwardIndex(int index) {
-        Node<T> node = head;
-        int pos = 0;
-        int count = 0;
-        try {
-            while (pos != index) {
-                node = node.getPointer();
-                count++;
-                pos++;
-            }
-            node.setPointer(null);
-            size = count + 1;
-        } catch (Exception e) {
-            throw new IndexOutOfBoundsException("Index Out Of Bounds");
-        }
-    }
-
-    public void removeBackwardData(T data) {
-        Node<T> node = head;
-        int count = 0;
-        try {
-            while (node.getData() != data) {
-                node = node.getPointer();
-                count++;
-            }
-            head = node;
-            size -= count;
-        } catch (Exception e) {
-            throw new NoSuchElementException("No Such Element");
-        }
-    }
-
-    public void removeBackwardIndex(int index) {
-        int pos = 0;
-        int count = 0;
-        Node<T> node = head;
-        try {
-            while (pos != index) {
-                node = node.getPointer();
-                count++;
-                pos++;
-            }
-            head = node;
-            size -= count;
-        } catch (Exception e) {
-            throw new IndexOutOfBoundsException("Index Out Of Bounds");
-        }
-    }
-
-    public void describeNodeData(T data) {
-        if (head == null) {
-            throw new NoSuchElementException("Empty List");
-        }
-        if (head.getData() == data) {
-            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", head.getData(), 0);
-            return;
-        }
-        if (tail.getData() == data) {
-            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", tail.getData(), size - 1);
-            return;
-        }
-        Node<T> node = head;
-        int index = 0;
-        while (node.hasPointer()) {
-            if (node.getData() == data) {
-                System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", node.getData(), index);
-                return;
-            }
-            node = node.getPointer();
-            index++;
-        }
-        throw new NoSuchElementException("No Such Element");
-    }
-
-    public void describeNodeIndex(int index) {
-        if (head == null) {
-            throw new NoSuchElementException("Empty List");
-        }
-        if (0 == index) {
-            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", head.getData(), 0);
-            return;
-        }
-        if ((size - 1) == index) {
-            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", tail.getData(), size - 1);
-            return;
-        }
-        Node<T> node = head;
-        int pos = 0;
-        while (node.hasPointer()) {
-            if (pos == index) {
-                System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", node.getData(), pos);
-                return;
-            }
-            node = node.getPointer();
-            pos++;
-        }
-        throw new NoSuchElementException("No Such Element");
-    }
-
-    public int indexOf(T data) {
-        int pos = 0;
-        Node<T> node = head;
-
-        while (node.getPointer() != null) {
-            pos++;
-            node = node.getPointer();
-            if (node.getData() == data) {
-                System.out.printf("indeks => %s\n", pos);
-                return pos;
-            }
-        }
-        throw new NoSuchElementException("No Such Element");
-    }
-
-    public boolean isEmpty() {
-        if (size == 0) {
-            System.out.println("List is Empty");
-            return true;
-        }
-        System.out.println("List is filled");
-        return false;
-    }
-
-    public void unique() {
-    }
-
-    public void sort() {
-    }
-
-    public void updateByData(T data, T newData) {
-        if (head == null)
-            throw new NoSuchElementException("Empty List");
-
-        Node<T> node = head;
-        Node<T> newNode = new Node<T>(newData);
-
-        if (node.getData() == data) {
-            head = newNode;
-            newNode.setPointer(node.getPointer());
-            node.setPointer(null);
-            return;
-        }
-        while (node.getPointer().getPointer() != null) {
-            if (node.getPointer().getData() == data) {
-                newNode.setPointer(node.getPointer().getPointer());
-                node.setPointer(newNode);
-                return;
-            }
-            node = node.getPointer();
-        }
-        if (tail.getData() == data) {
-            newNode.setPointer(null);
-            node.setPointer(newNode);
-            tail = newNode;
-            return;
-        }
-        if (node.getPointer().getData() != data) {
-            throw new NoSuchElementException("No Such Element");
-        }
-    }
-
-    public void updateByIndex(int index, T newData) {
-        if (head == null)
-            throw new NoSuchElementException("Empty List");
-
-        int pos = 0;
-        Node<T> node = head;
-        Node<T> newNode = new Node<T>(newData);
-
-        if (0 == index) {
-            head = newNode;
-            newNode.setPointer(node.getPointer());
-            node.setPointer(null);
-            return;
-        }
-        while (node.getPointer().getPointer() != null) {
-            if (index - pos == 1) {
-                newNode.setPointer(node.getPointer().getPointer());
-                node.setPointer(newNode);
-                return;
-            }
-            pos++;
-            node = node.getPointer();
-        }
-        if ((size - 1) == index) {
-            newNode.setPointer(null);
-            node.setPointer(newNode);
-            tail = newNode;
-            return;
-        }
-        if ((size - 1) < index)
-            throw new IndexOutOfBoundsException("Index Out Of Bounds");
-    }
-
-    public void clear() {
-        head = null;
-        size = 0;
-    }
-
-    public void traverse() {
-        if (head == null) {
-            System.out.println("Empty Linked List");
-            return;
-        }
-        Node<T> node = head;
-        while (node.hasPointer()) {
-            System.out.printf("[%s] -> ", node.getData());
-            node = node.getPointer();
-        }
-        System.out.printf("[%s] -> null\n", node.getData());
-    }
-
-    public boolean contain(T data) {
-        Node<T> node = head;
-        while (node.getPointer() != null) {
-            node = node.getPointer();
-        }
-        if (node.getData() == data) {
-            System.out.println("Data is true");
-            return true;
-        } else {
-            throw new NoSuchElementException("No Such Element");
-        }
-    }
-
-    public T get(int index) {
-        Node<T> node = head;
-        int pos = 0;
-        while (node.getPointer() != null) {
-            if (pos == index) {
-                System.out.printf("data => [%s]\n", node.getData());
-                return node.getData();
-            }
-            node = node.getPointer();
-            pos++;
-        }
-        if (size - 1 == index) {
-            System.out.printf("data => [%s]\n", node.getData());
-            return node.getData();
-        }
-        throw new IndexOutOfBoundsException("Index Out Of Bounds");
-    }
-
-    public int size() {
-        System.out.println("Size ::> " + size);
-        return size;
-    }
-
-    public void traverseFromData(T data) {
-        try {
-            if (head == null) {
-                System.out.println("Empty Linked List");
-                return;
-            }
-            Node<T> node = head;
-            while (node.getData() != data) {
-                node = node.getPointer();
-            }
-            while (node.getPointer() != null) {
-                System.out.printf("[%s] -> ", node.getData());
-                node = node.getPointer();
-            }
-            System.out.printf("[%s] -> null\n", node.getData());
-        } catch (Exception E) {
-            throw new NoSuchElementException("No Such Element");
-        }
-    }
-
-    public void traverseFromIndex(int index) {
-        Node<T> node = head;
-        int pos = 0;
-        while (node.getPointer().getPointer() != null) {
-            pos++;
-            node = node.getPointer();
-        }
-        if (pos == index) {
-            while (node.getPointer() != null) {
-                System.out.printf("[%s] -> ", node.getData());
-                node = node.getPointer();
-            }
-            System.out.printf("[%s] -> null\n", node.getData());
-            return;
-        }
-        if (pos != index) {
-            throw new IndexOutOfBoundsException("Index Out Of Bounds");
-        }
-    }
-
-}

From 536d386f77ccad18c15da6fab4a9602892d5d1de Mon Sep 17 00:00:00 2001
From: eveline0205 <evelinegabriela7@gmail.com>
Date: Thu, 20 Feb 2020 22:56:49 -0800
Subject: [PATCH 5/5] Tugas Struktur Data

---
 assignment-01/H071181317/Main.java            |  23 +
 assignment-01/H071181317/Node.java            |  24 +
 .../H071181317/SingleLinkedList.java          | 650 ++++++++++++++++++
 3 files changed, 697 insertions(+)
 create mode 100644 assignment-01/H071181317/Main.java
 create mode 100644 assignment-01/H071181317/Node.java
 create mode 100644 assignment-01/H071181317/SingleLinkedList.java

diff --git a/assignment-01/H071181317/Main.java b/assignment-01/H071181317/Main.java
new file mode 100644
index 0000000..31a4c53
--- /dev/null
+++ b/assignment-01/H071181317/Main.java
@@ -0,0 +1,23 @@
+public class Main {
+    public static void main(String[] args) {
+        SingleLinkedList<String> str = new SingleLinkedList<>();
+        SingleLinkedList<String> str2 = new SingleLinkedList<>();
+	SingleLinkedList<Integer> integer = new SingleLinkedList<Integer>();	
+
+        str.isEmpty();
+        str.traverse();
+        str.append("1");
+        str.append("2");
+        str.append("3");
+        str.append("4");
+        str.append("5");
+        str2.append("data1");
+        str.mergeAppend(str2);
+        str.traverse();
+        str.indexOf("data1");
+        str.prependBeforeIndex("6", 0);
+        str.traverse();
+
+    }
+
+}
\ No newline at end of file
diff --git a/assignment-01/H071181317/Node.java b/assignment-01/H071181317/Node.java
new file mode 100644
index 0000000..d2b443f
--- /dev/null
+++ b/assignment-01/H071181317/Node.java
@@ -0,0 +1,24 @@
+public class Node<T> {
+    private T data;
+    private Node<T> pointer;
+
+    public Node(T data) {
+        this.data = data;
+    }
+
+    public Node<T> getPointer() {
+        return pointer;
+    }
+
+    public void setPointer(Node<T> pointer) {
+        this.pointer = pointer;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    public boolean hasPointer() {
+        return pointer != null;
+    }
+}
diff --git a/assignment-01/H071181317/SingleLinkedList.java b/assignment-01/H071181317/SingleLinkedList.java
new file mode 100644
index 0000000..c0bbc28
--- /dev/null
+++ b/assignment-01/H071181317/SingleLinkedList.java
@@ -0,0 +1,650 @@
+import java.util.NoSuchElementException;
+
+public class SingleLinkedList<T> {
+    private Node<T> head;
+    private Node<T> tail;
+    private int size;
+
+    public void append(T data) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = new Node<T>(data);
+            head.setPointer(tail);
+            size++;
+            return;
+        }
+        Node<T> newNode = new Node<T>(data);
+        tail.setPointer(newNode);
+        tail = newNode;
+        size++;
+    }
+
+    public void appendAfterData(T data, T after) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = new Node<T>(data);
+            head.setPointer(tail);
+            size++;
+            return;
+        }
+
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(data);
+
+        while (node.getPointer() != null) {
+            if (node.getData() == after) {
+                newNode.setPointer(node.getPointer());
+                node.setPointer(newNode);
+                size++;
+                return;
+            }
+            if (tail.getData() == after || node.getData() != after) {
+                append(data);
+                size++;
+                return;
+            }
+            node = node.getPointer();
+        }
+    }
+
+    public void appendAfterIndex(T data, int index) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = new Node<T>(data);
+            head.setPointer(tail);
+            size++;
+            return;
+        }
+
+        int pos = 0;
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(data);
+
+        while (node.getPointer() != null) {
+            if (pos == index) {
+                newNode.setPointer(node.getPointer());
+                node.setPointer(newNode);
+                size++;
+                return;
+            }
+            pos++;
+            node = node.getPointer();
+        }
+        if ((size - 1) == index || pos != index) {
+            append(data);
+            size++;
+            return;
+        }
+    }
+
+    public void appendVarargs(T... datas) {
+        for (T data : datas) {
+            append(data);
+            size++;
+        }
+    }
+
+    public void prependVarargs(T... datas) {
+        for (T data : datas) {
+            prepend(data);
+            size++;
+        }
+    }
+
+    public void mergeAppend(SingleLinkedList<T> list) {
+        tail.setPointer(list.head);
+        tail = list.tail;
+        size += list.size;
+        return;
+    }
+
+    public void mergePrepend(SingleLinkedList<T> list) {
+        head = list.head;
+        list.tail.setPointer(list.head);
+        size += list.size;
+        return;
+    }
+
+    public void prepend(T data) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+
+        if (tail == null) {
+            tail = head;
+            Node<T> newNode = new Node<T>(data);
+            newNode.setPointer(tail);
+            head = newNode;
+            size++;
+            return;
+        }
+        Node<T> newNode = new Node<T>(data);
+        newNode.setPointer(head);
+        head = newNode;
+        size++;
+    }
+
+    public void prependBeforeData(T data, T before) {
+        Node<T> newNode = new Node<T>(data);
+
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = head;
+            newNode.setPointer(tail);
+            head = newNode;
+            size++;
+            return;
+        }
+
+        Node<T> node = head;
+
+        while (node.getPointer().getPointer() != null) {
+            if (node.getPointer().getData() == before) {
+                newNode.setPointer(node.getPointer());
+                node.setPointer(newNode);
+                size++;
+                return;
+            }
+            if (node.getData() == before || node.getData() != before) {
+                prepend(data);
+                size++;
+                return;
+            }
+            node = node.getPointer();
+        }
+    }
+
+    public void prependBeforeIndex(T data, int index) {
+        if (head == null) {
+            head = new Node<T>(data);
+            size++;
+            return;
+        }
+        if (tail == null) {
+            tail = new Node<T>(data);
+            head.setPointer(tail);
+            size++;
+            return;
+        }
+
+        int pos = 0;
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(data);
+
+        while (node.getPointer().getPointer() != null) {
+            if ((pos + 1) == index) {
+                newNode.setPointer(node.getPointer());
+                node.setPointer(newNode);
+                size++;
+                return;
+            }
+            if (0 == index || pos != index) {
+                prepend(data);
+                size++;
+                return;
+            }
+            node = node.getPointer();
+            pos++;
+        }
+    }
+
+    public void removeByData(T data) {
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            if (node.getPointer().getData() == data) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            if (node.getData() == data) {
+                removeHead();
+            }
+            node = node.getPointer();
+        }
+        if (tail.getData() == data) {
+            removeTail();
+        }
+    }
+
+    public void removeByIndex(int index) {
+        int pos = 0;
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            if (index - pos == 1) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            pos++;
+            node = node.getPointer();
+        }
+        if (0 == index) {
+            removeHead();
+        }
+        if (size == index) {
+            removeTail();
+        }
+        if ((size - 1) < index) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+    public void removeAfterData(T data) {
+        Node<T> node = head;
+        while (node.getPointer() != null) {
+            if (node.getData() == data) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            node = node.getPointer();
+        }
+        if (node.getPointer() == tail) {
+            node.setPointer(null);
+            tail = node;
+        }
+    }
+
+    public void removeAfterIndex(int index) {
+        int pos = 0;
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            if (pos == index) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            pos++;
+            node = node.getPointer();
+        }
+        if (size - index == 2) {
+            removeTail();
+        }
+        if ((size - 1) < index) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+    public void removeBeforeData(T data) {
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            if (node.getData() == data) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            node = node.getPointer();
+        }
+        if (head.getData() == data) {
+            removeHead();
+        }
+    }
+
+    public void removeBeforeIndex(int index) {
+        Node<T> node = head;
+        int pos = 0;
+
+        if ((pos + 1) == index) {
+            head = head.getPointer();
+            size--;
+            return;
+        }
+        while (node.getPointer() != null) {
+            if ((index) - pos == 2) {
+                node.setPointer(node.getPointer().getPointer());
+                size--;
+                return;
+            }
+            node = node.getPointer();
+            pos++;
+        }
+        throw new IndexOutOfBoundsException("Index Out Of Bounds");
+    }
+
+    public void removeHead() {
+        if (head == null) {
+            throw new NoSuchElementException("Empty List");
+        }
+        head = head.getPointer();
+        size--;
+    }
+
+    public void removeTail() {
+        if (head == null) {
+            throw new NoSuchElementException("Empty List");
+        } else if (tail == null) {
+            throw new NoSuchElementException("Head");
+        } else if (tail == head) {
+            throw new NoSuchElementException("Head is Tail");
+        }
+        Node<T> node = head;
+        while (node.getPointer().getPointer() != null) {
+            node = node.getPointer();
+        }
+        node.setPointer(null);
+        tail = node;
+        size--;
+    }
+
+    public void removeForwardData(T data) {
+        Node<T> node = head;
+        int count = 0;
+        try {
+            while (node.getData() != data) {
+                node = node.getPointer();
+                count++;
+            }
+            node.setPointer(null);
+            size = count + 1;
+        } catch (Exception e) {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public void removeForwardIndex(int index) {
+        Node<T> node = head;
+        int pos = 0;
+        int count = 0;
+        try {
+            while (pos != index) {
+                node = node.getPointer();
+                count++;
+                pos++;
+            }
+            node.setPointer(null);
+            size = count + 1;
+        } catch (Exception e) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+    public void removeBackwardData(T data) {
+        Node<T> node = head;
+        int count = 0;
+        try {
+            while (node.getData() != data) {
+                node = node.getPointer();
+                count++;
+            }
+            head = node;
+            size -= count;
+        } catch (Exception e) {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public void removeBackwardIndex(int index) {
+        int pos = 0;
+        int count = 0;
+        Node<T> node = head;
+        try {
+            while (pos != index) {
+                node = node.getPointer();
+                count++;
+                pos++;
+            }
+            head = node;
+            size -= count;
+        } catch (Exception e) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+    public void describeNodeData(T data) {
+        if (head == null) {
+            throw new NoSuchElementException("Empty List");
+        }
+        if (head.getData() == data) {
+            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", head.getData(), 0);
+            return;
+        }
+        if (tail.getData() == data) {
+            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", tail.getData(), size - 1);
+            return;
+        }
+        Node<T> node = head;
+        int index = 0;
+        while (node.hasPointer()) {
+            if (node.getData() == data) {
+                System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", node.getData(), index);
+                return;
+            }
+            node = node.getPointer();
+            index++;
+        }
+        throw new NoSuchElementException("No Such Element");
+    }
+
+    public void describeNodeIndex(int index) {
+        if (head == null) {
+            throw new NoSuchElementException("Empty List");
+        }
+        if (0 == index) {
+            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", head.getData(), 0);
+            return;
+        }
+        if ((size - 1) == index) {
+            System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", tail.getData(), size - 1);
+            return;
+        }
+        Node<T> node = head;
+        int pos = 0;
+        while (node.hasPointer()) {
+            if (pos == index) {
+                System.out.printf("{\n  data\t: %s\n  index\t: %d\n}\n", node.getData(), pos);
+                return;
+            }
+            node = node.getPointer();
+            pos++;
+        }
+        throw new NoSuchElementException("No Such Element");
+    }
+
+    public int indexOf(T data) {
+        int pos = 0;
+        Node<T> node = head;
+
+        while (node.getPointer() != null) {
+            pos++;
+            node = node.getPointer();
+            if (node.getData() == data) {
+                System.out.printf("indeks => %s\n", pos);
+                return pos;
+            }
+        }
+        throw new NoSuchElementException("No Such Element");
+    }
+
+    public boolean isEmpty() {
+        if (size == 0) {
+            System.out.println("List is Empty");
+            return true;
+        }
+        System.out.println("List is filled");
+        return false;
+    }
+
+    public void unique() {
+    }
+
+    public void sort() {
+    }
+
+    public void updateByData(T data, T newData) {
+        if (head == null)
+            throw new NoSuchElementException("Empty List");
+
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(newData);
+
+        if (node.getData() == data) {
+            head = newNode;
+            newNode.setPointer(node.getPointer());
+            node.setPointer(null);
+            return;
+        }
+        while (node.getPointer().getPointer() != null) {
+            if (node.getPointer().getData() == data) {
+                newNode.setPointer(node.getPointer().getPointer());
+                node.setPointer(newNode);
+                return;
+            }
+            node = node.getPointer();
+        }
+        if (tail.getData() == data) {
+            newNode.setPointer(null);
+            node.setPointer(newNode);
+            tail = newNode;
+            return;
+        }
+        if (node.getPointer().getData() != data) {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public void updateByIndex(int index, T newData) {
+        if (head == null)
+            throw new NoSuchElementException("Empty List");
+
+        int pos = 0;
+        Node<T> node = head;
+        Node<T> newNode = new Node<T>(newData);
+
+        if (0 == index) {
+            head = newNode;
+            newNode.setPointer(node.getPointer());
+            node.setPointer(null);
+            return;
+        }
+        while (node.getPointer().getPointer() != null) {
+            if (index - pos == 1) {
+                newNode.setPointer(node.getPointer().getPointer());
+                node.setPointer(newNode);
+                return;
+            }
+            pos++;
+            node = node.getPointer();
+        }
+        if ((size - 1) == index) {
+            newNode.setPointer(null);
+            node.setPointer(newNode);
+            tail = newNode;
+            return;
+        }
+        if ((size - 1) < index)
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+    }
+
+    public void clear() {
+        head = null;
+        size = 0;
+    }
+
+    public void traverse() {
+        if (head == null) {
+            System.out.println("Empty Linked List");
+            return;
+        }
+        Node<T> node = head;
+        while (node.hasPointer()) {
+            System.out.printf("[%s] -> ", node.getData());
+            node = node.getPointer();
+        }
+        System.out.printf("[%s] -> null\n", node.getData());
+    }
+
+    public boolean contain(T data) {
+        Node<T> node = head;
+        while (node.getPointer() != null) {
+            node = node.getPointer();
+        }
+        if (node.getData() == data) {
+            System.out.println("Data is true");
+            return true;
+        } else {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public T get(int index) {
+        Node<T> node = head;
+        int pos = 0;
+        while (node.getPointer() != null) {
+            if (pos == index) {
+                System.out.printf("data => [%s]\n", node.getData());
+                return node.getData();
+            }
+            node = node.getPointer();
+            pos++;
+        }
+        if (size - 1 == index) {
+            System.out.printf("data => [%s]\n", node.getData());
+            return node.getData();
+        }
+        throw new IndexOutOfBoundsException("Index Out Of Bounds");
+    }
+
+    public int size() {
+        System.out.println("Size ::> " + size);
+        return size;
+    }
+
+    public void traverseFromData(T data) {
+        try {
+            if (head == null) {
+                System.out.println("Empty Linked List");
+                return;
+            }
+            Node<T> node = head;
+            while (node.getData() != data) {
+                node = node.getPointer();
+            }
+            while (node.getPointer() != null) {
+                System.out.printf("[%s] -> ", node.getData());
+                node = node.getPointer();
+            }
+            System.out.printf("[%s] -> null\n", node.getData());
+        } catch (Exception E) {
+            throw new NoSuchElementException("No Such Element");
+        }
+    }
+
+    public void traverseFromIndex(int index) {
+        Node<T> node = head;
+        int pos = 0;
+        while (node.getPointer().getPointer() != null) {
+            pos++;
+            node = node.getPointer();
+        }
+        if (pos == index) {
+            while (node.getPointer() != null) {
+                System.out.printf("[%s] -> ", node.getData());
+                node = node.getPointer();
+            }
+            System.out.printf("[%s] -> null\n", node.getData());
+            return;
+        }
+        if (pos != index) {
+            throw new IndexOutOfBoundsException("Index Out Of Bounds");
+        }
+    }
+
+}