Merge remote-tracking branch 'upstream/master'

2019-12-03 15:27:45 +05:30
parent 3bcb5ce809 1b81033840
commit ac357ee98c
592 changed files with 16258 additions and 4492 deletions
@@ -7,8 +7,6 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.

 - [Validating Input With Finite Automata in Java](https://www.baeldung.com/java-finite-automata)
 - [Example of Hill Climbing Algorithm](https://www.baeldung.com/java-hill-climbing-algorithm)
- [Monte Carlo Tree Search for Tic-Tac-Toe Game](https://www.baeldung.com/java-monte-carlo-tree-search)
- [Binary Search Algorithm in Java](https://www.baeldung.com/java-binary-search)
 - [Introduction to Minimax Algorithm](https://www.baeldung.com/java-minimax-algorithm)
 - [How to Calculate Levenshtein Distance in Java?](https://www.baeldung.com/java-levenshtein-distance)
 - [How to Find the Kth Largest Element in Java](https://www.baeldung.com/java-kth-largest-element)
@@ -14,8 +14,6 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [A Guide to the Folding Technique in Java](https://www.baeldung.com/folding-hashing-technique)
 - [Creating a Triangle with for Loops in Java](https://www.baeldung.com/java-print-triangle)
 - [Efficient Word Frequency Calculator in Java](https://www.baeldung.com/java-word-frequency)
- [Interpolation Search in Java](https://www.baeldung.com/java-interpolation-search)
 - [The K-Means Clustering Algorithm in Java](https://www.baeldung.com/java-k-means-clustering-algorithm)
 - [Creating a Custom Annotation in Java](https://www.baeldung.com/java-custom-annotation)
- [Breadth-First Search Algorithm in Java](https://www.baeldung.com/java-breadth-first-search)
 - More articles: [[<-- prev]](/algorithms-miscellaneous-2) [[next -->]](/algorithms-miscellaneous-4)
@@ -5,7 +5,6 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 ### Relevant articles:

 - [Multi-Swarm Optimization Algorithm in Java](https://www.baeldung.com/java-multi-swarm-algorithm)
- [String Search Algorithms for Large Texts](https://www.baeldung.com/java-full-text-search-algorithms)
 - [Check If a String Contains All The Letters of The Alphabet](https://www.baeldung.com/java-string-contains-all-letters)
 - [Find the Middle Element of a Linked List](https://www.baeldung.com/java-linked-list-middle-element)
 - [Find Substrings That Are Palindromes in Java](https://www.baeldung.com/java-palindrome-substrings)
@@ -1,25 +0,0 @@
-package com.baeldung.algorithms;
-
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import com.baeldung.algorithms.string.search.StringSearchAlgorithms;
-
-public class StringSearchAlgorithmsUnitTest {
-	
-	
-	@Test
-	public void testStringSearchAlgorithms(){
-		String text = "This is some nice text.";
-		String pattern = "some";
-		
-		int realPosition = text.indexOf(pattern);
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.simpleTextSearch(pattern.toCharArray(), text.toCharArray()));
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.RabinKarpMethod(pattern.toCharArray(), text.toCharArray()));
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.KnuthMorrisPrattSearch(pattern.toCharArray(), text.toCharArray()));
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSimpleSearch(pattern.toCharArray(), text.toCharArray()));
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSearch(pattern.toCharArray(), text.toCharArray()));
-	}
-
-}
@@ -0,0 +1,67 @@
+package com.baeldung.algorithms.combinatorics;
+
+import java.util.*;
+
+import static java.util.Collections.swap;
+
+public class Combinatorics {
+
+    public static List<List<Integer>> permutations(List<Integer> sequence) {
+        List<List<Integer>> results = new ArrayList<>();
+        permutationsInternal(sequence, results, 0);
+        return results;
+    }
+
+    private static void permutationsInternal(List<Integer> sequence, List<List<Integer>> results, int index) {
+        if (index == sequence.size() - 1) {
+            results.add(new ArrayList<>(sequence));
+        }
+
+        for (int i = index; i < sequence.size(); i++) {
+            swap(sequence, i, index);
+            permutationsInternal(sequence, results, index + 1);
+            swap(sequence, i, index);
+        }
+    }
+
+    public static List<List<Integer>> combinations(List<Integer> inputSet, int k) {
+        List<List<Integer>> results = new ArrayList<>();
+        combinationsInternal(inputSet, k, results, new ArrayList<>(), 0);
+        return results;
+    }
+
+    private static void combinationsInternal(
+      List<Integer> inputSet, int k, List<List<Integer>> results, ArrayList<Integer> accumulator, int index) {
+        int leftToAccumulate = k - accumulator.size();
+        int possibleToAcculumate = inputSet.size() - index;
+
+        if (accumulator.size() == k) {
+            results.add(new ArrayList<>(accumulator));
+        } else if (leftToAccumulate <= possibleToAcculumate) {
+            combinationsInternal(inputSet, k, results, accumulator, index + 1);
+
+            accumulator.add(inputSet.get(index));
+            combinationsInternal(inputSet, k, results, accumulator, index + 1);
+            accumulator.remove(accumulator.size() - 1);
+        }
+    }
+
+    public static List<List<Character>> powerSet(List<Character> sequence) {
+        List<List<Character>> results = new ArrayList<>();
+        powerSetInternal(sequence, results, new ArrayList<>(), 0);
+        return results;
+    }
+
+    private static void powerSetInternal(
+      List<Character> set, List<List<Character>> powerSet, List<Character> accumulator, int index) {
+        if (index == set.size()) {
+            powerSet.add(new ArrayList<>(accumulator));
+        } else {
+            accumulator.add(set.get(index));
+
+            powerSetInternal(set, powerSet, accumulator, index + 1);
+            accumulator.remove(accumulator.size() - 1);
+            powerSetInternal(set, powerSet, accumulator, index + 1);
+        }
+    }
+}
@@ -0,0 +1,80 @@
+package com.baeldung.algorithms.combinatorics;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+public class CombinatoricsUnitTest {
+
+    @Test
+    public void givenEmptySequence_whenCallingPermutations_ShouldReturnEmptyList() {
+        List<Integer> sequence = Arrays.asList();
+
+        List<List<Integer>> permutations = Combinatorics.permutations(sequence);
+
+        assertEquals(0, permutations.size());
+    }
+
+    @Test
+    public void givenOneElementSequence_whenCallingPermutations_ShouldReturnPermutations() {
+        List<Integer> sequence = Arrays.asList(1);
+
+        List<List<Integer>> permutations = Combinatorics.permutations(sequence);
+
+        assertEquals(1, permutations.size());
+        assertEquals(1, permutations.get(0).size());
+        assertSame(1, permutations.get(0).get(0));
+    }
+
+    @Test
+    public void givenFourElementsSequence_whenCallingPermutations_ShouldReturnPermutations() {
+        List<Integer> sequence = Arrays.asList(1, 2, 3, 4);
+
+        List<List<Integer>> permutations = Combinatorics.permutations(sequence);
+
+        assertEquals(24, permutations.size());
+        assertEquals(24, new HashSet<>(permutations).size());
+    }
+
+    @Test
+    public void givenTwoElements_whenCalling3Combinations_ShouldReturnEmptyList() {
+        List<Integer> set = Arrays.asList(1, 2);
+
+        List<List<Integer>> combinations = Combinatorics.combinations(set, 3);
+
+        assertEquals(0, combinations.size());
+    }
+
+    @Test
+    public void givenThreeElements_whenCalling3Combinations_ShouldReturnOneCombination() {
+        List<Integer> set = Arrays.asList(1, 2, 3);
+
+        List<List<Integer>> combinations = Combinatorics.combinations(set, 3);
+
+        assertEquals(1, combinations.size());
+        assertEquals(combinations.get(0), Arrays.asList(1, 2, 3));
+    }
+
+    @Test
+    public void givenFourElements_whenCalling2Combinations_ShouldReturnCombinations() {
+        List<Integer> set = Arrays.asList(1, 2, 3, 4);
+
+        List<List<Integer>> combinations = Combinatorics.combinations(set, 2);
+
+        assertEquals(6, combinations.size());
+        assertEquals(6, new HashSet<>(combinations).size());
+    }
+
+    @Test
+    public void givenFourElements_whenCallingPowerSet_ShouldReturn15Sets() {
+        List<Character> sequence = Arrays.asList('a', 'b', 'c', 'd');
+
+        List<List<Character>> combinations = Combinatorics.powerSet(sequence);
+
+        assertEquals(16, combinations.size());
+    }
+}
@@ -0,0 +1,11 @@
+## Algorithms - Searching
+
+This module contains articles about searching algorithms.
+
+### Relevant articles:
+- [Binary Search Algorithm in Java](https://www.baeldung.com/java-binary-search)
+- [Depth First Search in Java](https://www.baeldung.com/java-depth-first-search)
+- [Interpolation Search in Java](https://www.baeldung.com/java-interpolation-search)
+- [Breadth-First Search Algorithm in Java](https://www.baeldung.com/java-breadth-first-search)
+- [String Search Algorithms for Large Texts](https://www.baeldung.com/java-full-text-search-algorithms)
+- [Monte Carlo Tree Search for Tic-Tac-Toe Game](https://www.baeldung.com/java-monte-carlo-tree-search)
@@ -0,0 +1,37 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>algorithms-searching</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-searching</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${org.assertj.core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>algorithms-searching</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <properties>
+        <org.assertj.core.version>3.9.0</org.assertj.core.version>
+    </properties>
+
+</project>
@@ -1,55 +1,55 @@
-package com.baeldung.algorithms.binarysearch;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-public class BinarySearch {
-
-    public int runBinarySearchIteratively(int[] sortedArray, int key, int low, int high) {
-
-        int index = Integer.MAX_VALUE;
-
-        while (low <= high) {
-
-            int mid = (low + high) / 2;
-
-            if (sortedArray[mid] < key) {
-                low = mid + 1;
-            } else if (sortedArray[mid] > key) {
-                high = mid - 1;
-            } else if (sortedArray[mid] == key) {
-                index = mid;
-                break;
-            }
-        }
-        return index;
-    }
-
-    public int runBinarySearchRecursively(int[] sortedArray, int key, int low, int high) {
-
-        int middle = (low + high) / 2;
-        if (high < low) {
-            return -1;
-        }
-
-        if (key == sortedArray[middle]) {
-          return middle;
-        } else if (key < sortedArray[middle]) {
-          return runBinarySearchRecursively(sortedArray, key, low, middle - 1);
-        } else {
-          return runBinarySearchRecursively(sortedArray, key, middle + 1, high);
-        }
-    }
-
-    public int runBinarySearchUsingJavaArrays(int[] sortedArray, Integer key) {
-        int index = Arrays.binarySearch(sortedArray, key);
-        return index;
-    }
-
-    public int runBinarySearchUsingJavaCollections(List<Integer> sortedList, Integer key) {
-        int index = Collections.binarySearch(sortedList, key);
-        return index;
-    }
-
-}
+package com.baeldung.algorithms.binarysearch;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class BinarySearch {
+
+    public int runBinarySearchIteratively(int[] sortedArray, int key, int low, int high) {
+
+        int index = Integer.MAX_VALUE;
+
+        while (low <= high) {
+
+            int mid = (low + high) / 2;
+
+            if (sortedArray[mid] < key) {
+                low = mid + 1;
+            } else if (sortedArray[mid] > key) {
+                high = mid - 1;
+            } else if (sortedArray[mid] == key) {
+                index = mid;
+                break;
+            }
+        }
+        return index;
+    }
+
+    public int runBinarySearchRecursively(int[] sortedArray, int key, int low, int high) {
+
+        int middle = (low + high) / 2;
+        if (high < low) {
+            return -1;
+        }
+
+        if (key == sortedArray[middle]) {
+          return middle;
+        } else if (key < sortedArray[middle]) {
+          return runBinarySearchRecursively(sortedArray, key, low, middle - 1);
+        } else {
+          return runBinarySearchRecursively(sortedArray, key, middle + 1, high);
+        }
+    }
+
+    public int runBinarySearchUsingJavaArrays(int[] sortedArray, Integer key) {
+        int index = Arrays.binarySearch(sortedArray, key);
+        return index;
+    }
+
+    public int runBinarySearchUsingJavaCollections(List<Integer> sortedList, Integer key) {
+        int index = Collections.binarySearch(sortedList, key);
+        return index;
+    }
+
+}
@@ -0,0 +1,227 @@
+package com.baeldung.algorithms.dfs;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+public class BinaryTree {
+
+    Node root;
+
+    public void add(int value) {
+        root = addRecursive(root, value);
+    }
+
+    private Node addRecursive(Node current, int value) {
+
+        if (current == null) {
+            return new Node(value);
+        }
+
+        if (value < current.value) {
+            current.left = addRecursive(current.left, value);
+        } else if (value > current.value) {
+            current.right = addRecursive(current.right, value);
+        }
+
+        return current;
+    }
+
+    public boolean isEmpty() {
+        return root == null;
+    }
+
+    public int getSize() {
+        return getSizeRecursive(root);
+    }
+
+    private int getSizeRecursive(Node current) {
+        return current == null ? 0 : getSizeRecursive(current.left) + 1 + getSizeRecursive(current.right);
+    }
+
+    public boolean containsNode(int value) {
+        return containsNodeRecursive(root, value);
+    }
+
+    private boolean containsNodeRecursive(Node current, int value) {
+        if (current == null) {
+            return false;
+        }
+
+        if (value == current.value) {
+            return true;
+        }
+
+        return value < current.value
+          ? containsNodeRecursive(current.left, value)
+          : containsNodeRecursive(current.right, value);
+    }
+
+    public void delete(int value) {
+        root = deleteRecursive(root, value);
+    }
+
+    private Node deleteRecursive(Node current, int value) {
+        if (current == null) {
+            return null;
+        }
+
+        if (value == current.value) {
+            // Case 1: no children
+            if (current.left == null && current.right == null) {
+                return null;
+            }
+
+            // Case 2: only 1 child
+            if (current.right == null) {
+                return current.left;
+            }
+
+            if (current.left == null) {
+                return current.right;
+            }
+
+            // Case 3: 2 children
+            int smallestValue = findSmallestValue(current.right);
+            current.value = smallestValue;
+            current.right = deleteRecursive(current.right, smallestValue);
+            return current;
+        }
+        if (value < current.value) {
+            current.left = deleteRecursive(current.left, value);
+            return current;
+        }
+
+        current.right = deleteRecursive(current.right, value);
+        return current;
+    }
+
+    private int findSmallestValue(Node root) {
+        return root.left == null ? root.value : findSmallestValue(root.left);
+    }
+
+    public void traverseInOrder(Node node) {
+        if (node != null) {
+            traverseInOrder(node.left);
+            visit(node.value);
+            traverseInOrder(node.right);
+        }
+    }
+
+    public void traversePreOrder(Node node) {
+        if (node != null) {
+            visit(node.value);
+            traversePreOrder(node.left);
+            traversePreOrder(node.right);
+        }
+    }
+
+    public void traversePostOrder(Node node) {
+        if (node != null) {
+            traversePostOrder(node.left);
+            traversePostOrder(node.right);
+            visit(node.value);
+        }
+    }
+
+    public void traverseLevelOrder() {
+        if (root == null) {
+            return;
+        }
+
+        Queue<Node> nodes = new LinkedList<>();
+        nodes.add(root);
+
+        while (!nodes.isEmpty()) {
+
+            Node node = nodes.remove();
+
+            System.out.print(" " + node.value);
+
+            if (node.left != null) {
+                nodes.add(node.left);
+            }
+
+            if (node.left != null) {
+                nodes.add(node.right);
+            }
+        }
+    }
+
+    
+    public void traverseInOrderWithoutRecursion() {
+        Stack<Node> stack = new Stack<Node>();
+        Node current = root;
+        stack.push(root);
+        while(! stack.isEmpty()) {
+            while(current.left != null) {
+                current = current.left;                
+                stack.push(current);                
+            }
+            current = stack.pop();
+            visit(current.value);
+            if(current.right != null) {
+                current = current.right;                
+                stack.push(current);
+            }
+        }
+    }
+    
+    public void traversePreOrderWithoutRecursion() {
+        Stack<Node> stack = new Stack<Node>();
+        Node current = root;
+        stack.push(root);
+        while(! stack.isEmpty()) {
+            current = stack.pop();
+            visit(current.value);
+            
+            if(current.right != null)
+                stack.push(current.right);
+                
+            if(current.left != null)
+                stack.push(current.left);
+        }        
+    }
+    
+    public void traversePostOrderWithoutRecursion() {
+        Stack<Node> stack = new Stack<Node>();
+        Node prev = root;
+        Node current = root;
+        stack.push(root);
+
+        while (!stack.isEmpty()) {
+            current = stack.peek();
+            boolean hasChild = (current.left != null || current.right != null);
+            boolean isPrevLastChild = (prev == current.right || (prev == current.left && current.right == null));
+
+            if (!hasChild || isPrevLastChild) {
+                current = stack.pop();
+                visit(current.value);
+                prev = current;
+            } else {
+                if (current.right != null) {
+                    stack.push(current.right);
+                }
+                if (current.left != null) {
+                    stack.push(current.left);
+                }
+            }
+        }   
+    }    
+    
+    private void visit(int value) {
+        System.out.print(" " + value);        
+    }
+    
+    class Node {
+        int value;
+        Node left;
+        Node right;
+
+        Node(int value) {
+            this.value = value;
+            right = null;
+            left = null;
+        }
+    }
+}
@@ -1,4 +1,4 @@
-package com.baeldung.graph;
+package com.baeldung.algorithms.dfs;

 import java.util.ArrayList;
 import java.util.HashMap;
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>
@@ -1,43 +1,41 @@
-package com.baeldung.algorithms.binarysearch;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Assert;
-import org.junit.Test;
-import com.baeldung.algorithms.binarysearch.BinarySearch;
-
-public class BinarySearchUnitTest {
-
-    int[] sortedArray = { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
-    int key = 6;
-    int expectedIndexForSearchKey = 7;
-    int low = 0;
-    int high = sortedArray.length - 1;
-    List<Integer> sortedList = Arrays.asList(0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9);
-    
-    @Test
-    public void givenASortedArrayOfIntegers_whenBinarySearchRunIterativelyForANumber_thenGetIndexOfTheNumber() {
-        BinarySearch binSearch = new BinarySearch();
-        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchIteratively(sortedArray, key, low, high));
-    }
-
-    @Test
-    public void givenASortedArrayOfIntegers_whenBinarySearchRunRecursivelyForANumber_thenGetIndexOfTheNumber() {
-        BinarySearch binSearch = new BinarySearch();
-        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchRecursively(sortedArray, key, low, high));
-    }
-    
-    @Test
-    public void givenASortedArrayOfIntegers_whenBinarySearchRunUsingArraysClassStaticMethodForANumber_thenGetIndexOfTheNumber() {
-        BinarySearch binSearch = new BinarySearch();
-        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchUsingJavaArrays(sortedArray, key));
-    }
-    
-    @Test
-    public void givenASortedListOfIntegers_whenBinarySearchRunUsingCollectionsClassStaticMethodForANumber_thenGetIndexOfTheNumber() {
-        BinarySearch binSearch = new BinarySearch();
-        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchUsingJavaCollections(sortedList, key));
-    }
-    
-}
+package com.baeldung.algorithms.binarysearch;
+
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BinarySearchUnitTest {
+
+    int[] sortedArray = { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
+    int key = 6;
+    int expectedIndexForSearchKey = 7;
+    int low = 0;
+    int high = sortedArray.length - 1;
+    List<Integer> sortedList = Arrays.asList(0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9);
+    
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunIterativelyForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchIteratively(sortedArray, key, low, high));
+    }
+
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunRecursivelyForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchRecursively(sortedArray, key, low, high));
+    }
+    
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunUsingArraysClassStaticMethodForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchUsingJavaArrays(sortedArray, key));
+    }
+    
+    @Test
+    public void givenASortedListOfIntegers_whenBinarySearchRunUsingCollectionsClassStaticMethodForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchUsingJavaCollections(sortedList, key));
+    }
+    
+}
@@ -0,0 +1,136 @@
+package com.baeldung.algorithms.dfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class BinaryTreeUnitTest {
+
+    @Test
+    public void givenABinaryTree_WhenAddingElements_ThenTreeNotEmpty() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(!bt.isEmpty());
+    }
+
+    @Test
+    public void givenABinaryTree_WhenAddingElements_ThenTreeContainsThoseElements() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(bt.containsNode(6));
+        assertTrue(bt.containsNode(4));
+
+        assertFalse(bt.containsNode(1));
+    }
+
+    @Test
+    public void givenABinaryTree_WhenAddingExistingElement_ThenElementIsNotAdded() {
+
+        BinaryTree bt = createBinaryTree();
+
+        int initialSize = bt.getSize();
+
+        assertTrue(bt.containsNode(3));
+        bt.add(3);
+        assertEquals(initialSize, bt.getSize());
+    }
+
+    @Test
+    public void givenABinaryTree_WhenLookingForNonExistingElement_ThenReturnsFalse() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertFalse(bt.containsNode(99));
+    }
+
+    @Test
+    public void givenABinaryTree_WhenDeletingElements_ThenTreeDoesNotContainThoseElements() {
+
+        BinaryTree bt = createBinaryTree();
+
+        assertTrue(bt.containsNode(9));
+        bt.delete(9);
+        assertFalse(bt.containsNode(9));
+    }
+
+    @Test
+    public void givenABinaryTree_WhenDeletingNonExistingElement_ThenTreeDoesNotDelete() {
+
+        BinaryTree bt = createBinaryTree();
+
+        int initialSize = bt.getSize();
+
+        assertFalse(bt.containsNode(99));
+        bt.delete(99);
+        assertFalse(bt.containsNode(99));
+        assertEquals(initialSize, bt.getSize());
+    }
+
+    @Test
+    public void it_deletes_the_root() {
+        int value = 12;
+        BinaryTree bt = new BinaryTree();
+        bt.add(value);
+
+        assertTrue(bt.containsNode(value));
+        bt.delete(value);
+        assertFalse(bt.containsNode(value));
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingInOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traverseInOrder(bt.root);
+        System.out.println();
+        bt.traverseInOrderWithoutRecursion();
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingPreOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traversePreOrder(bt.root);
+        System.out.println();
+        bt.traversePreOrderWithoutRecursion();
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingPostOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traversePostOrder(bt.root);
+        System.out.println();
+        bt.traversePostOrderWithoutRecursion();
+    }
+
+    @Test
+    public void givenABinaryTree_WhenTraversingLevelOrder_ThenPrintValues() {
+
+        BinaryTree bt = createBinaryTree();
+
+        bt.traverseLevelOrder();
+    }
+
+    private BinaryTree createBinaryTree() {
+        BinaryTree bt = new BinaryTree();
+
+        bt.add(6);
+        bt.add(4);
+        bt.add(8);
+        bt.add(3);
+        bt.add(5);
+        bt.add(7);
+        bt.add(9);
+
+        return bt;
+    }
+
+}
@@ -1,7 +1,8 @@
-package com.baeldung.graph;
+package com.baeldung.algorithms.dfs;

 import java.util.List;

+import com.baeldung.algorithms.dfs.Graph;
 import org.junit.Test;

 public class GraphUnitTest {
@@ -1,10 +1,10 @@
 package com.baeldung.algorithms.interpolationsearch;

-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 import org.junit.Before;
 import org.junit.Test;

+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class InterpolationSearchUnitTest {
    
    private int[] myData;
--- a/Show More
+++ b/Show More