Merge branch 'main' into exercise/completed

Author: tboychuk

2-0-data-structures-and-algorithms/src/main/java/com/bobocode/linked_list/LinkedList.java

@@ -1,5 +1,7 @@
 package com.bobocode.linked_list;
 
+import java.util.NoSuchElementException;
+
 /**
  * {@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.
@@ -65,6 +67,28 @@ public T get(int index) {
         throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
     }
 
+    /**
+     * Returns the first element of the list. Operation is performed in constant time O(1)
+     *
+     * @return the first element of the list
+     * @throws java.util.NoSuchElementException if list is empty
+     */
+    @Override
+    public T getFirst() {
+        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+    }
+
+    /**
+     * Returns the last element of the list. Operation is performed in constant time O(1)
+     *
+     * @return the last element of the list
+     * @throws java.util.NoSuchElementException if list is empty
+     */
+    @Override
+    public T getLast() {
+        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+    }
+
     /**
      * Removes an elements by its position index. In case provided index in out of the list bounds it
      * throws {@link IndexOutOfBoundsException}

2-0-data-structures-and-algorithms/src/main/java/com/bobocode/linked_list/List.java

@@ -1,18 +1,22 @@
 package com.bobocode.linked_list;
 
 
-public interface List<T> {
-    void add(T element);
+public interface List<E> {
+    void add(E element);
 
-    void add(int index, T element);
+    void add(int index, E element);
 
-    void set(int index, T element);
+    void set(int index, E element);
 
-    T get(int index);
+    E get(int index);
+
+    E getFirst();
+
+    E getLast();
 
     void remove(int index);
 
-    boolean contains(T element);
+    boolean contains(E element);
 
     boolean isEmpty();
 

2-0-data-structures-and-algorithms/src/test/java/com/bobocode/linked_list/LinkedListTest.java

@@ -6,6 +6,8 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestMethodOrder;
 
+import java.util.NoSuchElementException;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -36,7 +38,7 @@ void testGetFirstElementFromSingleElementList() {
     }
 
     @Test
-    @Order(4)
+    @Order(3)
     void testAddElements() {
         intList = LinkedList.of(43, 233, 54);
 
@@ -46,42 +48,59 @@ void testAddElements() {
         assertEquals(54, intList.get(2).intValue());
     }
 
+    @Test
+    @Order(4)
+    void testSize() {
+        intList = LinkedList.of(4, 7, 9, 0, 7);
+
+        int size = intList.size();
+
+        assertEquals(5, size);
+    }
 
     @Test
     @Order(5)
-    void testGetElements() {
-        intList = LinkedList.of(25, 87, 45);
-
-        int firstElement = intList.get(0);
-        int secondElement = intList.get(1);
-        int thirdElement = intList.get(2);
+    void testGetFirstElement() {
+        intList = LinkedList.of(31, 32);
 
-        assertEquals(25, firstElement);
-        assertEquals(87, secondElement);
-        assertEquals(45, thirdElement);
+        assertEquals(31, intList.getFirst().intValue());
     }
 
     @Test
-    @Order(16)
-    void testGetFirstElementFromEmptyList() {
-        assertThrows(IndexOutOfBoundsException.class, () -> intList.get(0));
+    @Order(6)
+    void testGetLastElement() {
+        intList = LinkedList.of(41, 42);
+
+        assertEquals(42, intList.getLast().intValue());
     }
 
     @Test
-    @Order(17)
-    void testGetElementByNegativeIndex() {
-        assertThrows(IndexOutOfBoundsException.class, () -> intList.get(-1));
+    @Order(7)
+    void testGetFirstOfEmptyList() { assertThrows(NoSuchElementException.class, () -> intList.getFirst()); }
+
+    @Test
+    @Order(8)
+    void testGetLastOfEmptyList() {
+        assertThrows(NoSuchElementException.class, () -> intList.getLast());
     }
 
+
     @Test
-    @Order(18)
-    void testGetElementByIndexEqualsToListSize() {
-        intList = LinkedList.of(33, 46, 25, 87, 45);
-        assertThrows(IndexOutOfBoundsException.class, () -> intList.get(5));
+    @Order(9)
+    void testGetElements() {
+        intList = LinkedList.of(25, 87, 45);
+
+        int firstElement = intList.get(0);
+        int secondElement = intList.get(1);
+        int thirdElement = intList.get(2);
+
+        assertEquals(25, firstElement);
+        assertEquals(87, secondElement);
+        assertEquals(45, thirdElement);
     }
 
     @Test
-    @Order(6)
+    @Order(10)
     void testAddElementByZeroIndexIntoEmptyList() {
         intList.add(0, 45);
 
@@ -90,7 +109,7 @@ void testAddElementByZeroIndexIntoEmptyList() {
     }
 
     @Test
-    @Order(7)
+    @Order(11)
     void testAddElementByIndexToTheEndOfList() {
         intList = LinkedList.of(98, 64, 23, 1, 3, 4);
 
@@ -102,7 +121,7 @@ void testAddElementByIndexToTheEndOfList() {
     }
 
     @Test
-    @Order(8)
+    @Order(12)
     void testAddElementToTheHeadOfNonEmptyList() {
         intList = LinkedList.of(4, 6, 8, 9, 0, 2);
 
@@ -114,7 +133,7 @@ void testAddElementToTheHeadOfNonEmptyList() {
     }
 
     @Test
-    @Order(9)
+    @Order(13)
     void testAddElementByIndex() {
         intList = LinkedList.of(43, 5, 6, 8);
 
@@ -130,14 +149,14 @@ void testAddElementByIndex() {
     }
 
     @Test
-    @Order(10)
+    @Order(14)
     void testAddElementByNegativeIndex() {
         assertThrows(IndexOutOfBoundsException.class, () -> intList.add(-1, 66));
 
     }
 
     @Test
-    @Order(11)
+    @Order(15)
     void testAddElementByIndexLargerThanListSize() {
         intList = LinkedList.of(4, 6, 11, 9);
 
@@ -146,7 +165,7 @@ void testAddElementByIndexLargerThanListSize() {
     }
 
     @Test
-    @Order(12)
+    @Order(16)
     void testAddElementByIndexEqualToSize() {
         intList = LinkedList.of(1, 2, 3, 4, 5); // size = 5
 
@@ -157,21 +176,21 @@ void testAddElementByIndexEqualToSize() {
     }
 
     @Test
-    @Order(13)
+    @Order(17)
     void testSetFirstElementOnEmptyTree() {
         assertThrows(IndexOutOfBoundsException.class, () -> intList.set(0, 34));
     }
 
     @Test
-    @Order(14)
+    @Order(18)
     void testSetElementByIndexEqualToSize() {
         intList = LinkedList.of(2, 3, 4); // size = 3
 
         assertThrows(IndexOutOfBoundsException.class, () -> intList.set(3, 222));
     }
 
     @Test
-    @Order(15)
+    @Order(19)
     void testSetElementByIndex() {
         intList = LinkedList.of(34, 78, 9, 8);
 
@@ -187,13 +206,32 @@ void testSetElementByIndex() {
     }
 
     @Test
-    @Order(19)
+    @Order(20)
+    void testGetFirstElementFromEmptyList() {
+        assertThrows(IndexOutOfBoundsException.class, () -> intList.get(0));
+    }
+
+    @Test
+    @Order(21)
+    void testGetElementByNegativeIndex() {
+        assertThrows(IndexOutOfBoundsException.class, () -> intList.get(-1));
+    }
+
+    @Test
+    @Order(22)
+    void testGetElementByIndexEqualsToListSize() {
+        intList = LinkedList.of(33, 46, 25, 87, 45);
+        assertThrows(IndexOutOfBoundsException.class, () -> intList.get(5));
+    }
+
+    @Test
+    @Order(23)
     void testRemoveElementFromEmptyList() {
         assertThrows(IndexOutOfBoundsException.class, () -> intList.remove(234));
     }
 
     @Test
-    @Order(20)
+    @Order(24)
     void testRemoveFirstElement() {
         intList = LinkedList.of(4, 6, 8, 9);
 
@@ -204,7 +242,7 @@ void testRemoveFirstElement() {
     }
 
     @Test
-    @Order(21)
+    @Order(25)
     void testRemoveLastElement() {
         intList = LinkedList.of(4, 6, 8, 9);
 
@@ -215,7 +253,7 @@ void testRemoveLastElement() {
     }
 
     @Test
-    @Order(22)
+    @Order(26)
     void testRemoveElement() {
         intList = LinkedList.of(1, 2, 3, 4, 5);
 
@@ -227,15 +265,15 @@ void testRemoveElement() {
     }
 
     @Test
-    @Order(23)
+    @Order(27)
     void testContainsOnEmptyList() {
         boolean contains = intList.contains(34);
 
         assertFalse(contains);
     }
 
     @Test
-    @Order(24)
+    @Order(28)
     void testContains() {
         intList = LinkedList.of(45, 6, 3, 6);
 
@@ -247,15 +285,15 @@ void testContains() {
     }
 
     @Test
-    @Order(25)
+    @Order(29)
     void testIsEmptyOnEmptyList() {
         boolean empty = intList.isEmpty();
 
         assertTrue(empty);
     }
 
     @Test
-    @Order(26)
+    @Order(30)
     void testIsEmpty() {
         intList = LinkedList.of(34, 5, 6);
 
@@ -265,33 +303,23 @@ void testIsEmpty() {
     }
 
     @Test
-    @Order(27)
+    @Order(31)
     void testSizeOnEmptyList() {
         int size = intList.size();
 
         assertEquals(0, size);
     }
 
     @Test
-    @Order(3)
-    void testSize() {
-        intList = LinkedList.of(4, 7, 9, 0, 7);
-
-        int size = intList.size();
-
-        assertEquals(5, size);
-    }
-
-    @Test
-    @Order(28)
+    @Order(32)
     void testClearOnEmptyList() {
         intList.clear();
 
         assertEquals(0, intList.size());
     }
 
     @Test
-    @Order(29)
+    @Order(33)
     void testClearChangesTheSize() {
         intList = LinkedList.of(4, 5, 6);
 
@@ -301,7 +329,7 @@ void testClearChangesTheSize() {
     }
 
     @Test
-    @Order(30)
+    @Order(34)
     void testClearRemovesElements() {
         intList = LinkedList.of(4, 5, 6);