bobocode-projects#2 Data Structures and Algorithms

Author: aarshakyan

2-0-data-structures-and-algorithms/2-2-1-node/src/main/java/com/bobobode/cs/Node.java

@@ -9,5 +9,31 @@
  * @author Taras Boychuk
  */
 public class Node<T> {
-    // todo:
+
+    private T value;
+    private Node<T> next;
+
+    public Node() {
+    }
+
+    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;
+    }
 }

2-0-data-structures-and-algorithms/2-2-1-node/src/main/java/com/bobobode/cs/Nodes.java

@@ -22,7 +22,7 @@ private Nodes() {
      * @return a new instance of {@link Node}
      */
     public static <T> Node<T> create(T element) {
-        throw new ExerciseNotCompletedException(); // todo:
+        return new Node<>(element);
     }
 
     /**
@@ -33,7 +33,7 @@ public static <T> Node<T> create(T element) {
      * @param <T>    a genetic type
      */
     public static <T> void link(Node<T> first, Node<T> second) {
-        throw new ExerciseNotCompletedException(); // todo:
+        first.setNext(second);
     }
 
     /**
@@ -46,7 +46,10 @@ public static <T> void link(Node<T> first, Node<T> second) {
      * @return a reference to a first node created based on firstElement
      */
     public static <T> Node<T> pairOf(T firstElement, T secondElement) {
-        throw new ExerciseNotCompletedException(); // todo:
+        Node<T> firstNode = create(firstElement);
+        Node<T> secondNode = create(secondElement);
+        firstNode.setNext(secondNode);
+        return firstNode;
     }
 
     /**
@@ -60,7 +63,9 @@ public static <T> Node<T> pairOf(T firstElement, T secondElement) {
      * @return a reference to the first node
      */
     public static <T> Node<T> closedPairOf(T firstElement, T secondElement) {
-        throw new ExerciseNotCompletedException(); // todo:
+        Node<T> firstNode = pairOf(firstElement, secondElement);
+        firstNode.getNext().setNext(firstNode);
+        return firstNode;
     }
 
     /**
@@ -72,7 +77,15 @@ public static <T> Node<T> closedPairOf(T firstElement, T secondElement) {
      * @return a reference to the first element of the chain
      */
     public static <T> Node<T> chainOf(T... elements) {
-        throw new ExerciseNotCompletedException(); // todo:
+        Node<T>[] array = new Node[elements.length];
+        for (int i = 0; i < elements.length; i++) {
+            Node<T> node = create(elements[i]);
+            array[i] = node;
+            if (i > 0) {
+                array[i - 1].setNext(node);
+            }
+        }
+        return array[0];
     }
 
     /**
@@ -85,6 +98,13 @@ public static <T> Node<T> chainOf(T... elements) {
      * @return a reference to the first element of the chain
      */
     public static <T> Node<T> circleOf(T... elements) {
-        throw new ExerciseNotCompletedException(); // todo:
+        Node<T> firstNode = chainOf(elements);
+        Node<T> lastNode = firstNode;
+
+        while (lastNode.getNext() != null) {
+            lastNode = lastNode.getNext();
+        }
+        lastNode.setNext(firstNode);
+        return firstNode;
     }
 }

2-0-data-structures-and-algorithms/2-2-2-stack/src/main/java/com/bobocode/cs/LinkedStack.java

@@ -2,6 +2,12 @@
 
 import com.bobocode.cs.exception.EmptyStackException;
 import com.bobocode.util.ExerciseNotCompletedException;
+import com.sun.security.auth.NTUserPrincipal;
+import org.checkerframework.checker.units.qual.A;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 /**
  * {@link LinkedStack} is a stack implementation that is based on singly linked generic nodes.
@@ -15,6 +21,10 @@
  * @author Serhii Hryhus
  */
 public class LinkedStack<T> implements Stack<T> {
+    private int size;
+
+    private Node<T> head;
+
 
     /**
      * This method creates a stack of provided elements
@@ -24,7 +34,11 @@ public class LinkedStack<T> implements Stack<T> {
      * @return a new stack of elements that were passed as method parameters
      */
     public static <T> LinkedStack<T> of(T... elements) {
-        throw new ExerciseNotCompletedException(); // todo: implement this method
+        LinkedStack<T> stack = new LinkedStack<>();
+        for (T element : elements) {
+            stack.push(element);
+        }
+        return stack;
     }
 
     /**
@@ -35,7 +49,13 @@ public static <T> LinkedStack<T> of(T... elements) {
      */
     @Override
     public void push(T element) {
-        throw new ExerciseNotCompletedException(); // todo: implement this method
+        if (element == null) {
+            throw new NullPointerException();
+        }
+        Node<T> tNode = new Node<>(element);
+        tNode.setNext(head);
+        head = tNode;
+        size++;
     }
 
     /**
@@ -47,7 +67,13 @@ public void push(T element) {
      */
     @Override
     public T pop() {
-        throw new ExerciseNotCompletedException(); // todo: implement this method
+        if (head == null) {
+            throw new EmptyStackException();
+        }
+        Node<T> nodeToReturn = head;
+        head = head.getNext();
+        size--;
+        return nodeToReturn.value;
     }
 
     /**
@@ -57,7 +83,7 @@ public T pop() {
      */
     @Override
     public int size() {
-        throw new ExerciseNotCompletedException(); // todo: implement this method
+        return size;
     }
 
     /**
@@ -67,7 +93,26 @@ public int size() {
      */
     @Override
     public boolean isEmpty() {
-        throw new ExerciseNotCompletedException(); // todo: implement this method;
+        return head == null;
     }
 
+    private static class Node<T> {
+        private final T value;
+
+        private Node<T> next;
+
+        private Node(T element) {
+            this.value = element;
+        }
+
+
+        public void setNext(Node<T> next) {
+            this.next = next;
+        }
+
+        public Node<T> getNext() {
+            return next;
+        }
+
+    }
 }

2-0-data-structures-and-algorithms/2-2-3-linked-queue/src/main/java/com/bobocode/cs/LinkedQueue.java

@@ -1,7 +1,5 @@
 package com.bobocode.cs;
 
-import com.bobocode.util.ExerciseNotCompletedException;
-
 /**
  * {@link LinkedQueue} implements FIFO {@link Queue}, using singly linked nodes. Nodes are stores in instances of nested
  * class Node. In order to perform operations {@link LinkedQueue#add(Object)} and {@link LinkedQueue#poll()}
@@ -15,14 +13,37 @@
  * @author Ivan Virchenko
  */
 public class LinkedQueue<T> implements Queue<T> {
+    static final class Node<T> {
+        private T element;
+        private Node<T> next;
+
+        static <T> Node<T> valueOf(T element) {
+            return new Node<>(element);
+        }
+
+        private Node(T element) {
+            this.element = element;
+        }
+    }
+
+    private Node<T> head;
+    private Node<T> tail;
+    private int size;
 
     /**
      * Adds an element to the end of the queue.
      *
      * @param element the element to add
      */
     public void add(T element) {
-        throw new ExerciseNotCompletedException(); // todo: implement this method
+        Node<T> newNode = Node.valueOf(element);
+        if (head == null) {
+            head = tail = newNode;
+        } else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
     }
 
     /**
@@ -31,7 +52,17 @@ 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 ExerciseNotCompletedException(); // todo: implement this method
+        if (head != null) {
+            T element = head.element;
+            head = head.next;
+            if (head == null) {
+                tail = null;
+            }
+            size--;
+            return element;
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -40,7 +71,7 @@ public T poll() {
      * @return an integer value that is a size of queue
      */
     public int size() {
-        throw new ExerciseNotCompletedException(); // todo: implement this method
+        return size;
     }
 
     /**
@@ -49,6 +80,6 @@ public int size() {
      * @return {@code true} if the queue is empty, returns {@code false} if it's not
      */
     public boolean isEmpty() {
-        throw new ExerciseNotCompletedException(); // todo: implement this method
+        return head == null;
     }
 }