Merge pull request #4 from eugenp/master

Sync

Author: dimitarsazdovski

algorithms/README.md

@@ -8,3 +8,4 @@
 - [Check If a Number Is Prime in Java](http://www.baeldung.com/java-prime-numbers)
 - [Example of Hill Climbing Algorithm](http://www.baeldung.com/java-hill-climbing-algorithm)
 - [Monte Carlo Tree Search for Tic-Tac-Toe Game](http://www.baeldung.com/java-monte-carlo-tree-search)
+- [String Search Algorithms for Large Texts](http://www.baeldung.com/java-full-text-search-algorithms)

algorithms/pom.xml

@@ -34,6 +34,11 @@
             <artifactId>jenetics</artifactId>
             <version>3.7.0</version>
         </dependency>
+        <dependency>
+            <groupId>org.jgrapht</groupId>
+            <artifactId>jgrapht-core</artifactId>
+            <version>1.0.1</version>
+        </dependency>
     </dependencies>
 
     <build>

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForce.java

@@ -2,9 +2,9 @@
 
 public class CycleDetectionBruteForce {
 
-    public static <T> boolean detectCycle(Node<T> head) {
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
         if (head == null) {
-            return false;
+            return new CycleDetectionResult<>(false, null);
         }
 
         Node<T> it1 = head;
@@ -25,14 +25,14 @@ public static <T> boolean detectCycle(Node<T> head) {
                 }
 
                 if (noOfTimesCurrentNodeVisited == 2) {
-                    return true;
+                    return new CycleDetectionResult<>(true, it1);
                 }
 
                 x--;
             }
         }
 
-        return false;
+        return new CycleDetectionResult<>(false, null);
     }
 
 }

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIterators.java

@@ -2,9 +2,9 @@
 
 public class CycleDetectionByFastAndSlowIterators {
 
-    public static <T> boolean detectCycle(Node<T> head) {
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
         if (head == null) {
-            return false;
+            return new CycleDetectionResult<>(false, null);
         }
 
         Node<T> slow = head;
@@ -15,11 +15,11 @@ public static <T> boolean detectCycle(Node<T> head) {
             fast = fast.next.next;
 
             if (slow == fast) {
-                return true;
+                return new CycleDetectionResult<>(true, fast);
             }
         }
 
-        return false;
+        return new CycleDetectionResult<>(false, null);
     }
 
 }

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashing.java

@@ -5,23 +5,23 @@
 
 public class CycleDetectionByHashing {
 
-    public static <T> boolean detectCycle(Node<T> head) {
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
         if (head == null) {
-            return false;
+            return new CycleDetectionResult<>(false, null);
         }
 
         Set<Node<T>> set = new HashSet<>();
         Node<T> node = head;
 
         while (node != null) {
             if (set.contains(node)) {
-                return true;
+                return new CycleDetectionResult<>(true, node);
             }
             set.add(node);
             node = node.next;
         }
 
-        return false;
+        return new CycleDetectionResult<>(false, null);
     }
 
 }

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionResult.java

@@ -0,0 +1,12 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionResult<T> {
+    boolean cycleExists;
+    Node<T> node;
+
+    public CycleDetectionResult(boolean cycleExists, Node<T> node) {
+        super();
+        this.cycleExists = cycleExists;
+        this.node = node;
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForce.java

@@ -3,26 +3,21 @@
 public class CycleRemovalBruteForce {
 
     public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        if (head == null) {
-            return false;
-        }
-
-        Node<T> slow = head;
-        Node<T> fast = head;
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
 
-        while (fast != null && fast.next != null) {
-            slow = slow.next;
-            fast = fast.next.next;
-
-            if (slow == fast) {
-                removeCycle(slow, head);
-                return true;
-            }
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
         }
 
-        return false;
+        return result.cycleExists;
     }
 
+    /**
+     * @param loopNodeParam - reference to the node where Flyods cycle 
+     * finding algorithm ends, i.e. the fast and the slow iterators
+     * meet.
+     * @param head - reference to the head of the list
+     */
     private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
         Node<T> it = head;
 
@@ -39,12 +34,12 @@ private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
     private static <T> boolean isNodeReachableFromLoopNode(Node<T> it, Node<T> loopNodeParam) {
         Node<T> loopNode = loopNodeParam;
 
-        while (loopNode.next != loopNodeParam) {
+        do {
             if (it == loopNode) {
                 return true;
             }
             loopNode = loopNode.next;
-        }
+        } while (loopNode.next != loopNodeParam);
 
         return false;
     }

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodes.java

@@ -3,28 +3,17 @@
 public class CycleRemovalByCountingLoopNodes {
 
     public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        if (head == null) {
-            return false;
-        }
-
-        Node<T> slow = head;
-        Node<T> fast = head;
-
-        while (fast != null && fast.next != null) {
-            slow = slow.next;
-            fast = fast.next.next;
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
 
-            if (slow == fast) {
-                int cycleLength = calculateCycleLength(slow);
-                removeCycle(head, cycleLength);
-                return true;
-            }
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
         }
 
-        return false;
+        return result.cycleExists;
     }
 
-    private static <T> void removeCycle(Node<T> head, int cycleLength) {
+    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
+        int cycleLength = calculateCycleLength(loopNodeParam);
         Node<T> cycleLengthAdvancedIterator = head;
         Node<T> it = head;
 

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodes.java

@@ -3,24 +3,13 @@
 public class CycleRemovalWithoutCountingLoopNodes {
 
     public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        if (head == null) {
-            return false;
-        }
-
-        Node<T> slow = head;
-        Node<T> fast = head;
-
-        while (fast != null && fast.next != null) {
-            slow = slow.next;
-            fast = fast.next.next;
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
 
-            if (slow == fast) {
-                removeCycle(slow, head);
-                return true;
-            }
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
         }
 
-        return false;
+        return result.cycleExists;
     }
 
     private static <T> void removeCycle(Node<T> meetingPointParam, Node<T> head) {

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForceTest.java

@@ -2,19 +2,22 @@
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(value = Parameterized.class)
 public class CycleDetectionBruteForceTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
 
-    @Test
-    public void givenNormalList_dontDetectLoop() {
-        Node<Integer> root = createList();
-        Assert.assertFalse(CycleDetectionBruteForce.detectCycle(root));
+    public CycleDetectionBruteForceTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
     }
 
     @Test
-    public void givenCyclicList_detectLoop() {
-        Node<Integer> root = createList();
-        createLoop(root);
-        Assert.assertTrue(CycleDetectionBruteForce.detectCycle(root));
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionBruteForce.detectCycle(head).cycleExists);
     }
 }