Bael 1773 refactor (#4498)

* Strange git issue with README.MD, wouldn't revert the file

* BAEL-1773 Coe moved to algorithm module

algorithms/src/main/java/com/baeldung/algorithms/middleelementlookup/MiddleElementLookup.java

@@ -0,0 +1,88 @@
+package com.baeldung.algorithms.middleelementlookup;
+
+import java.util.LinkedList;
+import java.util.Optional;
+
+public class MiddleElementLookup {
+
+    public static Optional<String> findMiddleElementLinkedList(LinkedList<String> linkedList) {
+        if (linkedList == null || linkedList.isEmpty()) {
+            return Optional.empty();
+        }
+
+        return Optional.ofNullable(linkedList.get((linkedList.size() - 1) / 2));
+    }
+
+    public static Optional<String> findMiddleElementFromHead(Node head) {
+        if (head == null) {
+            return Optional.empty();
+        }
+
+        // calculate the size of the list
+        Node current = head;
+        int size = 1;
+        while (current.hasNext()) {
+            current = current.next();
+            size++;
+        }
+
+        // iterate till the middle element
+        current = head;
+        for (int i = 0; i < (size - 1) / 2; i++) {
+            current = current.next();
+        }
+
+        return Optional.ofNullable(current.data());
+    }
+
+    public static Optional<String> findMiddleElementFromHead1PassRecursively(Node head) {
+        if (head == null) {
+            return Optional.empty();
+        }
+
+        MiddleAuxRecursion middleAux = new MiddleAuxRecursion();
+        findMiddleRecursively(head, middleAux);
+        return Optional.ofNullable(middleAux.middle.data());
+    }
+
+    private static void findMiddleRecursively(Node node, MiddleAuxRecursion middleAux) {
+        if (node == null) {
+            // reached the end
+            middleAux.length = middleAux.length / 2;
+            return;
+        }
+        middleAux.length++;
+        findMiddleRecursively(node.next(), middleAux);
+
+        if (middleAux.length == 0) {
+            // found the middle
+            middleAux.middle = node;
+        }
+
+        middleAux.length--;
+    }
+
+    public static Optional<String> findMiddleElementFromHead1PassIteratively(Node head) {
+        if (head == null) {
+            return Optional.empty();
+        }
+
+        Node slowPointer = head;
+        Node fastPointer = head;
+
+        while (fastPointer.hasNext() && fastPointer.next()
+            .hasNext()) {
+            fastPointer = fastPointer.next()
+                .next();
+            slowPointer = slowPointer.next();
+        }
+
+        return Optional.ofNullable(slowPointer.data());
+    }
+
+    private static class MiddleAuxRecursion {
+        Node middle;
+        int length = 0;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/middleelementlookup/Node.java

@@ -0,0 +1,34 @@
+package com.baeldung.algorithms.middleelementlookup;
+
+public class Node {
+    private Node next;
+    private String data;
+
+    public Node(String data) {
+        this.data = data;
+    }
+
+    public String data() {
+        return data;
+    }
+
+    public void setData(String data) {
+        this.data = data;
+    }
+
+    public boolean hasNext() {
+        return next != null;
+    }
+
+    public Node next() {
+        return next;
+    }
+
+    public void setNext(Node next) {
+        this.next = next;
+    }
+
+    public String toString() {
+        return this.data;
+    }
+}

algorithms/src/test/java/algorithms/MiddleElementLookupUnitTest.java

@@ -0,0 +1,118 @@
+package algorithms;
+
+import com.baeldung.algorithms.middleelementlookup.MiddleElementLookup;
+import com.baeldung.algorithms.middleelementlookup.Node;
+import org.junit.Test;
+
+import java.util.LinkedList;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class MiddleElementLookupUnitTest {
+
+    @Test
+    public void whenFindingMiddleLinkedList_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead1PassRecursively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead1PassIteratively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenListEmptyOrNull_thenMiddleNotFound() {
+        // null list
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(null)
+          .isPresent());
+
+        // empty LinkedList
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(new LinkedList<>())
+          .isPresent());
+
+        // LinkedList with nulls
+        LinkedList<String> nullsList = new LinkedList<>();
+        nullsList.add(null);
+        nullsList.add(null);
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(nullsList)
+          .isPresent());
+
+        // nodes with null values
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(new Node(null))
+          .isPresent());
+    }
+
+    private static LinkedList<String> createLinkedList(int n) {
+        LinkedList<String> list = new LinkedList<>();
+
+        for (int i = 1; i <= n; i++) {
+            list.add(String.valueOf(i));
+        }
+
+        return list;
+    }
+
+    private static Node createNodesList(int n) {
+        Node head = new Node("1");
+        Node current = head;
+
+        for (int i = 2; i <= n; i++) {
+            Node newNode = new Node(String.valueOf(i));
+            current.setNext(newNode);
+            current = newNode;
+        }
+
+        return head;
+    }
+
+}