From 3990402294a59e6dc1e0401f0bca75a40427ac29 Mon Sep 17 00:00:00 2001
From: Gennady <genius163sam@gmail.com>
Date: Sat, 31 Aug 2019 08:04:05 +0400
Subject: [PATCH 1/3] feat(ll): Add linked list first solution

---
 .../main/java/com/bobocode/LinkedList.java    | 113 ++++++++++++++++--
 1 file changed, 103 insertions(+), 10 deletions(-)

diff --git a/linked-list/src/main/java/com/bobocode/LinkedList.java b/linked-list/src/main/java/com/bobocode/LinkedList.java
index bd6176a..595ed18 100644
--- a/linked-list/src/main/java/com/bobocode/LinkedList.java
+++ b/linked-list/src/main/java/com/bobocode/LinkedList.java
@@ -1,5 +1,9 @@
 package com.bobocode;
 
+import org.junit.platform.engine.support.hierarchical.Node;
+
+import java.util.Arrays;
+
 /**
  * {@link LinkedList} is a list implementation that is based on singly linked generic nodes. A node is implemented as
  * inner static class {@link Node<T>}. In order to keep track on nodes, {@link LinkedList} keeps a reference to a head node.
@@ -7,6 +11,9 @@
  * @param <T> generic type parameter
  */
 public class LinkedList<T> implements List<T> {
+    private Node<T> head;
+    private Node<T> lastNode;
+    private int size = 0;
 
     /**
      * This method creates a list of provided elements
@@ -16,7 +23,10 @@ public class LinkedList<T> implements List<T> {
      * @return a new list of elements the were passed as method parameters
      */
     public static <T> List<T> of(T... elements) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        LinkedList linkedList = new LinkedList();
+        Arrays.stream(elements)
+                .forEach(linkedList::add);
+        return linkedList;
     }
 
     /**
@@ -26,7 +36,17 @@ public static <T> List<T> of(T... elements) {
      */
     @Override
     public void add(T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (head == null) {
+            head = new Node(element);
+            head.setNext(head);
+            lastNode = head;
+        } else {
+            Node newNode = new Node(element);
+            newNode.setNext(head);
+            lastNode.setNext(newNode);
+            lastNode = newNode;
+        }
+        size++;
     }
 
     /**
@@ -38,7 +58,23 @@ public void add(T element) {
      */
     @Override
     public void add(int index, T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (index == 0) {
+            if (head == null) {
+                add(element);
+            } else {
+                Node<T> newNode = new Node<>(element);
+                newNode.setNext(head);
+                head = newNode;
+                size++;
+            }
+        } else {
+            Node<T> node = findNode(index - 1);
+            Node<T> next = node.getNext();
+            Node<T> newNode = new Node<>(element);
+            node.setNext(newNode);
+            newNode.setNext(next);
+            size++;
+        }
     }
 
     /**
@@ -50,7 +86,8 @@ public void add(int index, T element) {
      */
     @Override
     public void set(int index, T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        Node<T> node = findNode(index);
+        node.setValue(element);
     }
 
     /**
@@ -62,7 +99,7 @@ public void set(int index, T element) {
      */
     @Override
     public T get(int index) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return findNode(index).getValue();
     }
 
     /**
@@ -73,7 +110,15 @@ public T get(int index) {
      */
     @Override
     public void remove(int index) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (index == 0) {
+            head = findNode(1);
+            size--;
+            return;
+        }
+        Node<T> node = findNode(index);
+        Node<T> previousNode = findNode(index - 1);
+        previousNode.setNext(node.getNext());
+        size--;
     }
 
 
@@ -84,7 +129,17 @@ public void remove(int index) {
      */
     @Override
     public boolean contains(T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (isEmpty()) {
+            return false;
+        }
+        Node<T> node = head;
+        while(node.getNext() != head) {
+            if (node.getValue() == element) {
+                return true;
+            }
+            node = node.getNext();
+        }
+        return false;
     }
 
     /**
@@ -94,7 +149,7 @@ public boolean contains(T element) {
      */
     @Override
     public boolean isEmpty() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size == 0;
     }
 
     /**
@@ -104,7 +159,19 @@ public boolean isEmpty() {
      */
     @Override
     public int size() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size;
+    }
+
+    private Node<T> findNode(int index) {
+        if (index < 0 || index > size - 1 || isEmpty()) {
+            throw new IndexOutOfBoundsException();
+        }
+        Node<T> node = head;
+        while(index > 0) {
+            index--;
+            node = node.getNext();
+        }
+        return node;
     }
 
     /**
@@ -112,6 +179,32 @@ public int size() {
      */
     @Override
     public void clear() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        head = null;
+        size = 0;
+    }
+
+    private class Node<T> {
+        private T value;
+        private Node next;
+
+        public Node(T value) {
+            this.value = value;
+        }
+
+        public T getValue() {
+            return value;
+        }
+
+        public void setValue(T value) {
+            this.value = value;
+        }
+
+        public Node<T> getNext() {
+            return next;
+        }
+
+        public void setNext(Node<T> next) {
+            this.next = next;
+        }
     }
 }

From 4a37fc44759cfa3b10bb47da2e15c16b0d96680d Mon Sep 17 00:00:00 2001
From: Gennady <genius163sam@gmail.com>
Date: Sat, 31 Aug 2019 10:07:17 +0400
Subject: [PATCH 2/3] feat(ll): Refactor LinkedList class

---
 .../main/java/com/bobocode/LinkedList.java    | 112 ++++++++----------
 1 file changed, 52 insertions(+), 60 deletions(-)

diff --git a/linked-list/src/main/java/com/bobocode/LinkedList.java b/linked-list/src/main/java/com/bobocode/LinkedList.java
index 595ed18..ec27d82 100644
--- a/linked-list/src/main/java/com/bobocode/LinkedList.java
+++ b/linked-list/src/main/java/com/bobocode/LinkedList.java
@@ -1,7 +1,5 @@
 package com.bobocode;
 
-import org.junit.platform.engine.support.hierarchical.Node;
-
 import java.util.Arrays;
 
 /**
@@ -12,7 +10,6 @@
  */
 public class LinkedList<T> implements List<T> {
     private Node<T> head;
-    private Node<T> lastNode;
     private int size = 0;
 
     /**
@@ -22,8 +19,9 @@ public class LinkedList<T> implements List<T> {
      * @param <T>      generic type
      * @return a new list of elements the were passed as method parameters
      */
-    public static <T> List<T> of(T... elements) {
-        LinkedList linkedList = new LinkedList();
+    @SafeVarargs
+    static <T> List<T> of(T... elements) {
+        List<T> linkedList = new LinkedList<>();
         Arrays.stream(elements)
                 .forEach(linkedList::add);
         return linkedList;
@@ -36,17 +34,14 @@ public static <T> List<T> of(T... elements) {
      */
     @Override
     public void add(T element) {
-        if (head == null) {
-            head = new Node(element);
-            head.setNext(head);
-            lastNode = head;
+        if (isEmpty()) {
+            head = new Node<>(element);
+            head.next = head;
+            head.prev = head;
+            size++;
         } else {
-            Node newNode = new Node(element);
-            newNode.setNext(head);
-            lastNode.setNext(newNode);
-            lastNode = newNode;
+            insertNode(element, head);
         }
-        size++;
     }
 
     /**
@@ -59,21 +54,13 @@ public void add(T element) {
     @Override
     public void add(int index, T element) {
         if (index == 0) {
-            if (head == null) {
+            if (isEmpty()) {
                 add(element);
             } else {
-                Node<T> newNode = new Node<>(element);
-                newNode.setNext(head);
-                head = newNode;
-                size++;
+                head = insertNode(element, head);
             }
         } else {
-            Node<T> node = findNode(index - 1);
-            Node<T> next = node.getNext();
-            Node<T> newNode = new Node<>(element);
-            node.setNext(newNode);
-            newNode.setNext(next);
-            size++;
+            insertNode(element, findNode(index - 1).next);
         }
     }
 
@@ -87,7 +74,7 @@ public void add(int index, T element) {
     @Override
     public void set(int index, T element) {
         Node<T> node = findNode(index);
-        node.setValue(element);
+        node.value = element;
     }
 
     /**
@@ -99,7 +86,7 @@ public void set(int index, T element) {
      */
     @Override
     public T get(int index) {
-        return findNode(index).getValue();
+        return findNode(index).value;
     }
 
     /**
@@ -111,13 +98,18 @@ public T get(int index) {
     @Override
     public void remove(int index) {
         if (index == 0) {
-            head = findNode(1);
+            Node<T> newHead = head.next;
+            newHead.prev = head.prev;
+            head.prev.next = newHead;
+            head = newHead;
             size--;
             return;
         }
         Node<T> node = findNode(index);
-        Node<T> previousNode = findNode(index - 1);
-        previousNode.setNext(node.getNext());
+        Node<T> previousNode = node.prev;
+
+        previousNode.next = node.next;
+        node.next.prev = previousNode;
         size--;
     }
 
@@ -133,11 +125,11 @@ public boolean contains(T element) {
             return false;
         }
         Node<T> node = head;
-        while(node.getNext() != head) {
-            if (node.getValue() == element) {
+        while(node.next != head) {
+            if (node.value == element) {
                 return true;
             }
-            node = node.getNext();
+            node = node.next;
         }
         return false;
     }
@@ -162,49 +154,49 @@ public int size() {
         return size;
     }
 
+    /**
+     * Removes all list elements
+     */
+    @Override
+    public void clear() {
+        head = null;
+        size = 0;
+    }
+
     private Node<T> findNode(int index) {
-        if (index < 0 || index > size - 1 || isEmpty()) {
+        if (size - 1 < index || index < 0 || isEmpty()) {
             throw new IndexOutOfBoundsException();
         }
         Node<T> node = head;
         while(index > 0) {
             index--;
-            node = node.getNext();
+            node = node.next;
         }
         return node;
     }
 
-    /**
-     * Removes all list elements
-     */
-    @Override
-    public void clear() {
-        head = null;
-        size = 0;
-    }
+    private Node<T> insertNode(T element, Node<T> nextNode) {
+        Node<T> newNode = new Node<>(element);
+        Node<T> prevNode = nextNode.prev;
 
-    private class Node<T> {
-        private T value;
-        private Node next;
+        newNode.prev = prevNode;
+        newNode.next = nextNode;
 
-        public Node(T value) {
-            this.value = value;
-        }
+        prevNode.next = newNode;
+        nextNode.prev = newNode;
 
-        public T getValue() {
-            return value;
-        }
+        size++;
 
-        public void setValue(T value) {
-            this.value = value;
-        }
+        return newNode;
+    }
 
-        public Node<T> getNext() {
-            return next;
-        }
+    private class Node<V> {
+        private V value;
+        private Node<V> next;
+        private Node<V> prev;
 
-        public void setNext(Node<T> next) {
-            this.next = next;
+        Node(V value) {
+            this.value = value;
         }
     }
 }

From a545c0582dcfdb7a4f5e86c978157e0208c077d0 Mon Sep 17 00:00:00 2001
From: Gennady <genius163sam@gmail.com>
Date: Sat, 31 Aug 2019 10:21:38 +0400
Subject: [PATCH 3/3] feat(lq): Add implements LinkedQueue

---
 .../main/java/com/bobocode/LinkedQueue.java   | 33 ++++++++++++++++---
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/linked-queue/src/main/java/com/bobocode/LinkedQueue.java b/linked-queue/src/main/java/com/bobocode/LinkedQueue.java
index 3cde892..8ed94c0 100644
--- a/linked-queue/src/main/java/com/bobocode/LinkedQueue.java
+++ b/linked-queue/src/main/java/com/bobocode/LinkedQueue.java
@@ -8,6 +8,9 @@
  * @param <T> a generic parameter
  */
 public class LinkedQueue<T> implements Queue<T> {
+    private int size = 0;
+    private Node<T> head;
+    private Node<T> tale;
 
     /**
      * Adds an element to the end of the queue.
@@ -15,7 +18,14 @@ public class LinkedQueue<T> implements Queue<T> {
      * @param element the element to add
      */
     public void add(T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (isEmpty()) {
+            head = new Node<>(element);
+            tale = head;
+        } else {
+            tale.next = new Node<>(element);
+            tale = tale.next;
+        }
+        size++;
     }
 
     /**
@@ -24,7 +34,13 @@ public void add(T element) {
      * @return an element that was retrieved from the head or null if queue is empty
      */
     public T poll() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        if (isEmpty()) {
+            return null;
+        }
+        T value = head.value;
+        head = head.next;
+        size--;
+        return value;
     }
 
     /**
@@ -33,7 +49,7 @@ public T poll() {
      * @return an integer value that is a size of queue
      */
     public int size() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size;
     }
 
     /**
@@ -42,6 +58,15 @@ public int size() {
      * @return {@code true} if the queue is empty, returns {@code false} if it's not
      */
     public boolean isEmpty() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size == 0;
+    }
+
+    private class Node<V> {
+        private Node<V> next;
+        private V value;
+
+        Node(V value) {
+            this.value = value;
+        }
     }
 }