From 38768029c60cb73504fcb1bf6e57663cfea3d56f Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Fri, 3 May 2024 21:07:19 +0700
Subject: [PATCH 01/27] feat: implement SplayTree

---
 .../datastructures/trees/SplayTree.java       | 323 ++++++++++++++++++
 .../datastructures/trees/SplayTreeTest.java   | 102 ++++++
 2 files changed, 425 insertions(+)
 create mode 100644 src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
 create mode 100644 src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
new file mode 100644
index 000000000000..97623382eafd
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -0,0 +1,323 @@
+package com.thealgorithms.datastructures.trees;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Implementation of a Splay Tree data structure.
+ *
+ * <p>
+ * A splay tree is a self-adjusting binary search tree with the additional property
+ * that recently accessed elements are quick to access again. It performs basic
+ * operations such as insertion, deletion, and searching in O(log n) amortized time,
+ * where n is the number of elements in the tree.
+ * </p>
+ *
+ * <p>
+ * The key feature of splay trees is the splay operation, which moves a node closer
+ * to the root of the tree when it is accessed. This operation helps to maintain
+ * good balance and improves the overall performance of the tree. After performing
+ * a splay operation, the accessed node becomes the new root of the tree.
+ * </p>
+ *
+ * <p>
+ * Splay trees have applications in various areas, including caching, network routing,
+ * and dynamic optimality analysis.
+ * </p>
+ */
+public class SplayTree {
+
+    private static class Node {
+        int key;
+        Node left, right;
+
+        Node(int key) {
+            this.key = key;
+            left = right = null;
+        }
+    }
+
+    private Node root;
+
+    /**
+     * Constructs an empty SplayTree.
+     */
+    public SplayTree() {
+        root = null;
+    }
+
+    /**
+     * Zig operation.
+     *
+     * <p>
+     * The zig operation is used to perform a single rotation on a node to move it closer to
+     * the root of the tree. It is typically applied when the node is a left child of its parent
+     * and needs to be rotated to the right.
+     * </p>
+     *
+     * @param x The node to perform the zig operation on.
+     * @return The new root node after the operation.
+     */
+    private Node rotateRight(Node x) {
+        Node y = x.left;
+        x.left = y.right;
+        y.right = x;
+        return y;
+    }
+
+    /**
+     * Zag operation.
+     *
+     * <p>
+     * The zag operation is used to perform a single rotation on a node to move it closer to
+     * the root of the tree. It is typically applied when the node is a right child of its parent
+     * and needs to be rotated to the left.
+     * </p>
+     *
+     * @param x The node to perform the zag operation on.
+     * @return The new root node after the operation.
+     */
+    private Node rotateLeft(Node x) {
+        Node y = x.right;
+        x.right = y.left;
+        y.left = x;
+        return y;
+    }
+
+    /**
+     * Splay operation.
+     *
+     * <p>
+     * The splay operation is the core operation of a splay tree. It moves a specified node
+     * closer to the root of the tree by performing a series of rotations. The goal of the splay
+     * operation is to improve the access time for frequently accessed nodes by bringing them
+     * closer to the root.
+     * </p>
+     *
+     * <p>
+     * The splay operation consists of three main cases:
+     * <ul>
+     * <li>Zig-Zig case: Perform two consecutive rotations.</li>
+     * <li>Zig-Zag case: Perform two consecutive rotations in opposite directions.</li>
+     * <li>Zag-Zag case: Perform two consecutive rotations.</li>
+     * </ul>
+     * </p>
+     *
+     * <p>
+     * After performing the splay operation, the accessed node becomes the new root of the tree.
+     * </p>
+     *
+     * @param root The root of the subtree to splay.
+     * @param key  The key to splay around.
+     * @return The new root of the splayed subtree.
+     */
+    private Node splay(Node root, int key) {
+        if (root == null || root.key == key) return root;
+
+        if (root.key > key) {
+            if (root.left == null) return root;
+            // Zig-Zig case
+            if (root.left.key > key) {
+                // Recursive call to splay on grandchild
+                root.left.left = splay(root.left.left, key);
+                // Perform zig operation on parent
+                root = rotateRight(root);
+            } // Zig-Zag case
+            else if (root.left.key < key) {
+                // Recursive call to splay on grandchild
+                root.left.right = splay(root.left.right, key);
+                // Perform zag operation on parent
+                if (root.left.right != null) root.left = rotateLeft(root.left);
+            }
+
+            return (root.left == null) ? root : rotateRight(root);
+        } else {
+            if (root.right == null) return root;
+            // Zag-Zag case
+            if (root.right.key > key) {
+                // Recursive call to splay on grandchild
+                root.right.left = splay(root.right.left, key);
+                // Perform zig operation on parent
+                if (root.right.left != null) root.right = rotateRight(root.right);
+            } // Zag-Zig case
+            else if (root.right.key < key) {
+                // Recursive call to splay on grandchild
+                root.right.right = splay(root.right.right, key);
+                // Perform zag operation on parent
+                root = rotateLeft(root);
+            }
+
+            return (root.right == null) ? root : rotateLeft(root);
+        }
+    }
+
+    /**
+     * Insert a key into the SplayTree.
+     *
+     * @param key The key to insert.
+     */
+    public void insert(int key) {
+        root = insertRec(root, key);
+        root = splay(root, key);
+    }
+
+    /**
+     * Recursive function to insert a key.
+     *
+     * @param root The root of the subtree to insert the key into.
+     * @param key  The key to insert.
+     * @return The root of the modified subtree.
+     */
+    private Node insertRec(Node root, int key) {
+        if (root == null) return new Node(key);
+
+        if (root.key > key) {
+            root.left = insertRec(root.left, key);
+        } else if (root.key < key) {
+            root.right = insertRec(root.right, key);
+        }
+
+        return root;
+    }
+
+    /**
+     * Search for a key in the SplayTree.
+     *
+     * @param key The key to search for.
+     * @return True if the key is found, otherwise false.
+     */
+    public boolean search(int key) {
+        root = splay(root, key);
+        return root != null && root.key == key;
+    }
+
+    /**
+     * Delete a key from the SplayTree.
+     *
+     * @param key The key to delete.
+     */
+    public void delete(int key) {
+        root = deleteRec(root, key);
+    }
+
+    /**
+     * Recursive function to delete a key.
+     *
+     * @param root The root of the subtree to delete the key from.
+     * @param key  The key to delete.
+     * @return The root of the modified subtree.
+     */
+    private Node deleteRec(Node root, int key) {
+        if (root == null) return null;
+
+        if (root.key > key) {
+            root.left = deleteRec(root.left, key);
+        } else if (root.key < key) {
+            root.right = deleteRec(root.right, key);
+        } else {
+            // Found the node to delete
+            if (root.left == null)
+                return root.right;
+            else if (root.right == null)
+                return root.left;
+
+            // Node with two children: Get the inorder successor (smallest in the right subtree)
+            root.key = minValue(root.right);
+
+            // Delete the inorder successor
+            root.right = deleteRec(root.right, root.key);
+        }
+
+        return root;
+    }
+
+    /**
+     * Find the minimum value in a subtree.
+     *
+     * @param root The root of the subtree to find the minimum value in.
+     * @return The minimum value in the subtree.
+     */
+    private int minValue(Node root) {
+        int minValue = root.key;
+        while (root.left != null) {
+            minValue = root.left.key;
+            root = root.left;
+        }
+        return minValue;
+    }
+
+    /**
+     * Perform an in-order traversal of the SplayTree.
+     *
+     * @return A vector containing the keys in in-order traversal order.
+     */
+    public List<Integer> inOrder() {
+        List<Integer> result = new LinkedList<>();
+        inOrderRec(root, result);
+        return result;
+    }
+
+    /**
+     * Recursive function for in-order traversal.
+     *
+     * @param root   The root of the subtree to traverse.
+     * @param result The vector to store the traversal result.
+     */
+    private void inOrderRec(Node root, List<Integer> result) {
+        if (root != null) {
+            inOrderRec(root.left, result);
+            result.add(root.key);
+            inOrderRec(root.right, result);
+        }
+    }
+
+    /**
+     * Perform a pre-order traversal of the SplayTree.
+     *
+     * @return A vector containing the keys in pre-order traversal order.
+     */
+    public List<Integer> preOrder() {
+        List<Integer> result = new LinkedList<>();
+        preOrderRec(root, result);
+        return result;
+    }
+
+    /**
+     * Recursive function for pre-order traversal.
+     *
+     * @param root   The root of the subtree to traverse.
+     * @param result The vector to store the traversal result.
+     */
+    private void preOrderRec(Node root, List<Integer> result) {
+        if (root != null) {
+            result.add(root.key);
+            preOrderRec(root.left, result);
+            preOrderRec(root.right, result);
+        }
+    }
+
+    /**
+     * Perform a post-order traversal of the SplayTree.
+     *
+     * @return A vector containing the keys in post-order traversal order.
+     */
+    public List<Integer> postOrder() {
+        List<Integer> result = new LinkedList<>();
+        postOrderRec(root, result);
+        return result;
+    }
+
+    /**
+     * Recursive function for post-order traversal.
+     *
+     * @param root   The root of the subtree to traverse.
+     * @param result The vector to store the traversal result.
+     */
+    private void postOrderRec(Node root, List<Integer> result) {
+        if (root != null) {
+            postOrderRec(root.left, result);
+            postOrderRec(root.right, result);
+            result.add(root.key);
+        }
+    }
+}
diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
new file mode 100644
index 000000000000..e1995f0c2021
--- /dev/null
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -0,0 +1,102 @@
+package com.thealgorithms.datastructures.trees;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class SplayTreeTest {
+    @ParameterizedTest
+    @MethodSource("traversalOrders")
+    public void testTraversal(String traversalOrder) {
+        SplayTree tree = createComplexTree();
+
+        // Perform traversal based on the provided order and verify the result
+        List<Integer> expected = getExpectedTraversalResult(traversalOrder);
+        List<Integer> result = performTraversal(tree, traversalOrder);
+        assertEquals(expected, result);
+    }
+
+    @ParameterizedTest
+    @MethodSource("valuesToTest")
+    public void testSearch(int value) {
+        SplayTree tree = createComplexTree();
+
+        // Search for the value in the tree
+        assertTrue(tree.search(value));
+    }
+
+    @ParameterizedTest
+    @MethodSource("valuesToTest")
+    public void testDelete(int value) {
+        SplayTree tree = createComplexTree();
+
+        // Delete the value from the tree
+        assertTrue(tree.search(value)); // Ensure value is present before deletion
+        tree.delete(value);
+        assertFalse(tree.search(value)); // Ensure value is not present after deletion
+    }
+
+    // Method to provide different traversal orders as parameters
+    private static Stream<String> traversalOrders() {
+        return Stream.of("inOrder", "preOrder", "postOrder");
+    }
+
+    // Method to provide values for search and delete tests as parameters
+    private static Stream<Integer> valuesToTest() {
+        return Stream.of(1, 5, 10); // Values present in the complex tree
+    }
+
+    // Method to perform traversal based on the provided order
+    private List<Integer> performTraversal(SplayTree tree, String traversalOrder) {
+        switch (traversalOrder) {
+        case "inOrder":
+            return tree.inOrder();
+        case "preOrder":
+            return tree.preOrder();
+        case "postOrder":
+            return tree.postOrder();
+        default:
+            throw new IllegalArgumentException("Invalid traversal order: " + traversalOrder);
+        }
+    }
+
+    // Method to get the expected traversal result based on the provided order
+    private List<Integer> getExpectedTraversalResult(String traversalOrder) {
+        List<Integer> expected = new LinkedList<>();
+        switch (traversalOrder) {
+        case "inOrder":
+            expected.addAll(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+            break;
+        case "preOrder":
+            expected.addAll(Arrays.asList(10, 9, 8, 7, 3, 1, 2, 5, 4, 6));
+            break;
+        case "postOrder":
+            expected.addAll(Arrays.asList(2, 1, 4, 6, 5, 3, 7, 8, 9, 10));
+            break;
+        default:
+            throw new IllegalArgumentException("Invalid traversal order: " + traversalOrder);
+        }
+        return expected;
+    }
+
+    // Method to create a complex SplayTree instance for testing
+    private SplayTree createComplexTree() {
+        SplayTree tree = new SplayTree();
+        tree.insert(5);
+        tree.insert(2);
+        tree.insert(7);
+        tree.insert(1);
+        tree.insert(4);
+        tree.insert(6);
+        tree.insert(9);
+        tree.insert(3);
+        tree.insert(8);
+        tree.insert(10);
+        return tree;
+    }
+}

From 08f223f6256601864f88e59837248d69c4be368e Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Fri, 10 May 2024 11:35:21 +0700
Subject: [PATCH 02/27] chore(docs): update docstring

---
 .../datastructures/trees/SplayTree.java              | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 97623382eafd..f0028f3f2967 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -249,7 +249,7 @@ private int minValue(Node root) {
     /**
      * Perform an in-order traversal of the SplayTree.
      *
-     * @return A vector containing the keys in in-order traversal order.
+     * @return A list containing the keys in in-order traversal order.
      */
     public List<Integer> inOrder() {
         List<Integer> result = new LinkedList<>();
@@ -261,7 +261,7 @@ public List<Integer> inOrder() {
      * Recursive function for in-order traversal.
      *
      * @param root   The root of the subtree to traverse.
-     * @param result The vector to store the traversal result.
+     * @param result The list to store the traversal result.
      */
     private void inOrderRec(Node root, List<Integer> result) {
         if (root != null) {
@@ -274,7 +274,7 @@ private void inOrderRec(Node root, List<Integer> result) {
     /**
      * Perform a pre-order traversal of the SplayTree.
      *
-     * @return A vector containing the keys in pre-order traversal order.
+     * @return A list containing the keys in pre-order traversal order.
      */
     public List<Integer> preOrder() {
         List<Integer> result = new LinkedList<>();
@@ -286,7 +286,7 @@ public List<Integer> preOrder() {
      * Recursive function for pre-order traversal.
      *
      * @param root   The root of the subtree to traverse.
-     * @param result The vector to store the traversal result.
+     * @param result The list to store the traversal result.
      */
     private void preOrderRec(Node root, List<Integer> result) {
         if (root != null) {
@@ -299,7 +299,7 @@ private void preOrderRec(Node root, List<Integer> result) {
     /**
      * Perform a post-order traversal of the SplayTree.
      *
-     * @return A vector containing the keys in post-order traversal order.
+     * @return A list containing the keys in post-order traversal order.
      */
     public List<Integer> postOrder() {
         List<Integer> result = new LinkedList<>();
@@ -311,7 +311,7 @@ public List<Integer> postOrder() {
      * Recursive function for post-order traversal.
      *
      * @param root   The root of the subtree to traverse.
-     * @param result The vector to store the traversal result.
+     * @param result The list to store the traversal result.
      */
     private void postOrderRec(Node root, List<Integer> result) {
         if (root != null) {

From 6a61536d55478b9e4873f0de746b3755bcccd640 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Fri, 10 May 2024 11:52:19 +0700
Subject: [PATCH 03/27] ref: add `traverse` method

---
 .../datastructures/trees/SplayTree.java       | 46 ++++++++-----------
 1 file changed, 20 insertions(+), 26 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index f0028f3f2967..f7be12c67ba8 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -247,13 +247,24 @@ private int minValue(Node root) {
     }
 
     /**
-     * Perform an in-order traversal of the SplayTree.
+     * Perform a traversal of the SplayTree.
      *
-     * @return A list containing the keys in in-order traversal order.
+     * @param traverseOrder The order of traversal (IN_ORDER, PRE_ORDER, or POST_ORDER).
+     * @return A list containing the keys in the specified traversal order.
      */
-    public List<Integer> inOrder() {
+    public List<Integer> traverse(TraverseOrder traverseOrder) {
         List<Integer> result = new LinkedList<>();
-        inOrderRec(root, result);
+        switch (traverseOrder) {
+        case IN_ORDER:
+            inOrderRec(root, result);
+            break;
+        case PRE_ORDER:
+            preOrderRec(root, result);
+            break;
+        case POST_ORDER:
+            postOrderRec(root, result);
+            break;
+        }
         return result;
     }
 
@@ -271,17 +282,6 @@ private void inOrderRec(Node root, List<Integer> result) {
         }
     }
 
-    /**
-     * Perform a pre-order traversal of the SplayTree.
-     *
-     * @return A list containing the keys in pre-order traversal order.
-     */
-    public List<Integer> preOrder() {
-        List<Integer> result = new LinkedList<>();
-        preOrderRec(root, result);
-        return result;
-    }
-
     /**
      * Recursive function for pre-order traversal.
      *
@@ -296,17 +296,6 @@ private void preOrderRec(Node root, List<Integer> result) {
         }
     }
 
-    /**
-     * Perform a post-order traversal of the SplayTree.
-     *
-     * @return A list containing the keys in post-order traversal order.
-     */
-    public List<Integer> postOrder() {
-        List<Integer> result = new LinkedList<>();
-        postOrderRec(root, result);
-        return result;
-    }
-
     /**
      * Recursive function for post-order traversal.
      *
@@ -320,4 +309,9 @@ private void postOrderRec(Node root, List<Integer> result) {
             result.add(root.key);
         }
     }
+
+    /**
+     * Enum to specify the order of traversal.
+     */
+    public enum TraverseOrder { IN_ORDER, PRE_ORDER, POST_ORDER }
 }

From a3573360cdf8e3e39432e7913bfaef3be5096b13 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Fri, 10 May 2024 11:52:37 +0700
Subject: [PATCH 04/27] ref: update tests

---
 .../datastructures/trees/SplayTreeTest.java   | 40 +++++++------------
 1 file changed, 14 insertions(+), 26 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index e1995f0c2021..8896e8520aee 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -1,6 +1,8 @@
 package com.thealgorithms.datastructures.trees;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
 import java.util.LinkedList;
@@ -12,12 +14,12 @@
 public class SplayTreeTest {
     @ParameterizedTest
     @MethodSource("traversalOrders")
-    public void testTraversal(String traversalOrder) {
+    public void testTraversal(SplayTree.TraverseOrder traverseOrder) {
         SplayTree tree = createComplexTree();
 
         // Perform traversal based on the provided order and verify the result
-        List<Integer> expected = getExpectedTraversalResult(traversalOrder);
-        List<Integer> result = performTraversal(tree, traversalOrder);
+        List<Integer> expected = getExpectedTraversalResult(traverseOrder);
+        List<Integer> result = tree.traverse(traverseOrder);
         assertEquals(expected, result);
     }
 
@@ -42,8 +44,8 @@ public void testDelete(int value) {
     }
 
     // Method to provide different traversal orders as parameters
-    private static Stream<String> traversalOrders() {
-        return Stream.of("inOrder", "preOrder", "postOrder");
+    private static Stream<SplayTree.TraverseOrder> traversalOrders() {
+        return Stream.of(SplayTree.TraverseOrder.IN_ORDER, SplayTree.TraverseOrder.PRE_ORDER, SplayTree.TraverseOrder.POST_ORDER);
     }
 
     // Method to provide values for search and delete tests as parameters
@@ -51,35 +53,21 @@ private static Stream<Integer> valuesToTest() {
         return Stream.of(1, 5, 10); // Values present in the complex tree
     }
 
-    // Method to perform traversal based on the provided order
-    private List<Integer> performTraversal(SplayTree tree, String traversalOrder) {
-        switch (traversalOrder) {
-        case "inOrder":
-            return tree.inOrder();
-        case "preOrder":
-            return tree.preOrder();
-        case "postOrder":
-            return tree.postOrder();
-        default:
-            throw new IllegalArgumentException("Invalid traversal order: " + traversalOrder);
-        }
-    }
-
     // Method to get the expected traversal result based on the provided order
-    private List<Integer> getExpectedTraversalResult(String traversalOrder) {
+    private List<Integer> getExpectedTraversalResult(SplayTree.TraverseOrder traverseOrder) {
         List<Integer> expected = new LinkedList<>();
-        switch (traversalOrder) {
-        case "inOrder":
+        switch (traverseOrder) {
+        case IN_ORDER:
             expected.addAll(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
             break;
-        case "preOrder":
+        case PRE_ORDER:
             expected.addAll(Arrays.asList(10, 9, 8, 7, 3, 1, 2, 5, 4, 6));
             break;
-        case "postOrder":
+        case POST_ORDER:
             expected.addAll(Arrays.asList(2, 1, 4, 6, 5, 3, 7, 8, 9, 10));
             break;
         default:
-            throw new IllegalArgumentException("Invalid traversal order: " + traversalOrder);
+            throw new IllegalArgumentException("Invalid traversal order: " + traverseOrder);
         }
         return expected;
     }

From 35a77ab0ad5c9b67ea560523040e866343dc63fb Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Thu, 23 May 2024 10:19:46 +0700
Subject: [PATCH 05/27] ref: refactor - Do not allow duplicate keys and
 explicitly throw an exception if one is trying to include already existing
 key - Throw error on deletion if tree is empty - Performing the splay
 operation before recursion, ensuring that the node to be deleted is at the
 root or very close to it, simplifying the deletion process.

---
 .../datastructures/trees/SplayTree.java       | 72 +++++++------------
 1 file changed, 25 insertions(+), 47 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index f7be12c67ba8..49ae4e9efb57 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -162,19 +162,22 @@ public void insert(int key) {
     }
 
     /**
-     * Recursive function to insert a key.
+     * Recursive function to insert a key into a subtree.
      *
      * @param root The root of the subtree to insert the key into.
      * @param key  The key to insert.
-     * @return The root of the modified subtree.
+     * @return The root of the modified subtree after insertion.
+     * @throws IllegalArgumentException If the key to be inserted already exists in the subtree.
      */
     private Node insertRec(Node root, int key) {
         if (root == null) return new Node(key);
 
-        if (root.key > key) {
+        if (key < root.key) {
             root.left = insertRec(root.left, key);
-        } else if (root.key < key) {
+        } else if (key > root.key) {
             root.right = insertRec(root.right, key);
+        } else {
+            throw new IllegalArgumentException("Duplicate key: " + key);
         }
 
         return root;
@@ -192,58 +195,33 @@ public boolean search(int key) {
     }
 
     /**
-     * Delete a key from the SplayTree.
+     * Deletes a key from the SplayTree.
      *
      * @param key The key to delete.
+     * @throws IllegalArgumentException If the tree is empty.
      */
     public void delete(int key) {
-        root = deleteRec(root, key);
-    }
-
-    /**
-     * Recursive function to delete a key.
-     *
-     * @param root The root of the subtree to delete the key from.
-     * @param key  The key to delete.
-     * @return The root of the modified subtree.
-     */
-    private Node deleteRec(Node root, int key) {
-        if (root == null) return null;
-
-        if (root.key > key) {
-            root.left = deleteRec(root.left, key);
-        } else if (root.key < key) {
-            root.right = deleteRec(root.right, key);
-        } else {
-            // Found the node to delete
-            if (root.left == null)
-                return root.right;
-            else if (root.right == null)
-                return root.left;
+        if (root == null) {
+            throw new IllegalArgumentException("Cannot delete from an empty tree");
+        }
 
-            // Node with two children: Get the inorder successor (smallest in the right subtree)
-            root.key = minValue(root.right);
+        // Splay the tree with the key to be deleted
+        root = splay(root, key);
 
-            // Delete the inorder successor
-            root.right = deleteRec(root.right, root.key);
+        // If the key is not found at the root, return without deleting
+        if (root.key != key) {
+            return;
         }
 
-        return root;
-    }
-
-    /**
-     * Find the minimum value in a subtree.
-     *
-     * @param root The root of the subtree to find the minimum value in.
-     * @return The minimum value in the subtree.
-     */
-    private int minValue(Node root) {
-        int minValue = root.key;
-        while (root.left != null) {
-            minValue = root.left.key;
-            root = root.left;
+        // Handle deletion
+        if (root.left == null) {
+            root = root.right;
+        } else {
+            Node temp = root;
+            // Splay to bring the largest key in left subtree to root
+            root = splay(root.left, key);
+            root.right = temp.right;
         }
-        return minValue;
     }
 
     /**

From 897633d73ff2a5db96194bbd4b9ed0c54f454cf9 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Thu, 23 May 2024 10:40:43 +0700
Subject: [PATCH 06/27] chore: fix checkstyle warning - inner assignments
 should be avoided

---
 .../java/com/thealgorithms/datastructures/trees/SplayTree.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 49ae4e9efb57..52e4f762317a 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -33,7 +33,8 @@ private static class Node {
 
         Node(int key) {
             this.key = key;
-            left = right = null;
+            left = null;
+            right = null;
         }
     }
 

From 3d9cf0ee57f72e6ba39cadc13b3cc966e8f65c2c Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Thu, 23 May 2024 11:01:33 +0700
Subject: [PATCH 07/27] ref: add tests

---
 .../datastructures/trees/SplayTreeTest.java   | 51 ++++++++++++++-----
 1 file changed, 39 insertions(+), 12 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index 8896e8520aee..6ea16b3570f8 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -2,6 +2,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
@@ -16,10 +17,9 @@ public class SplayTreeTest {
     @MethodSource("traversalOrders")
     public void testTraversal(SplayTree.TraverseOrder traverseOrder) {
         SplayTree tree = createComplexTree();
-
-        // Perform traversal based on the provided order and verify the result
         List<Integer> expected = getExpectedTraversalResult(traverseOrder);
         List<Integer> result = tree.traverse(traverseOrder);
+
         assertEquals(expected, result);
     }
 
@@ -27,8 +27,6 @@ public void testTraversal(SplayTree.TraverseOrder traverseOrder) {
     @MethodSource("valuesToTest")
     public void testSearch(int value) {
         SplayTree tree = createComplexTree();
-
-        // Search for the value in the tree
         assertTrue(tree.search(value));
     }
 
@@ -37,23 +35,53 @@ public void testSearch(int value) {
     public void testDelete(int value) {
         SplayTree tree = createComplexTree();
 
-        // Delete the value from the tree
-        assertTrue(tree.search(value)); // Ensure value is present before deletion
+        assertTrue(tree.search(value));
+        tree.delete(value);
+        assertFalse(tree.search(value));
+    }
+
+    @ParameterizedTest
+    @MethodSource("nonExistentValues")
+    public void testSearchNonExistent(int value) {
+        SplayTree tree = createComplexTree();
+        assertFalse(tree.search(value));
+    }
+
+    @ParameterizedTest
+    @MethodSource("nonExistentValues")
+    public void testDeleteNonExistent(int value) {
+        SplayTree tree = createComplexTree();
+
         tree.delete(value);
-        assertFalse(tree.search(value)); // Ensure value is not present after deletion
+        assertFalse(tree.search(value));
+    }
+
+    @ParameterizedTest
+    @MethodSource("valuesToTest")
+    public void testDeleteThrowsExceptionForEmptyTree(int value) {
+        SplayTree tree = new SplayTree();
+        assertThrows(IllegalArgumentException.class, () -> tree.delete(value));
+    }
+
+    @ParameterizedTest
+    @MethodSource("valuesToTest")
+    public void testInsertThrowsExceptionForDuplicateKeys(int value) {
+        SplayTree tree = createComplexTree();
+        assertThrows(IllegalArgumentException.class, () -> tree.insert(value));
     }
 
-    // Method to provide different traversal orders as parameters
     private static Stream<SplayTree.TraverseOrder> traversalOrders() {
         return Stream.of(SplayTree.TraverseOrder.IN_ORDER, SplayTree.TraverseOrder.PRE_ORDER, SplayTree.TraverseOrder.POST_ORDER);
     }
 
-    // Method to provide values for search and delete tests as parameters
     private static Stream<Integer> valuesToTest() {
-        return Stream.of(1, 5, 10); // Values present in the complex tree
+        return Stream.of(1, 5, 10);
+    }
+
+    private static Stream<Integer> nonExistentValues() {
+        return Stream.of(0, 11, 15);
     }
 
-    // Method to get the expected traversal result based on the provided order
     private List<Integer> getExpectedTraversalResult(SplayTree.TraverseOrder traverseOrder) {
         List<Integer> expected = new LinkedList<>();
         switch (traverseOrder) {
@@ -72,7 +100,6 @@ private List<Integer> getExpectedTraversalResult(SplayTree.TraverseOrder travers
         return expected;
     }
 
-    // Method to create a complex SplayTree instance for testing
     private SplayTree createComplexTree() {
         SplayTree tree = new SplayTree();
         tree.insert(5);

From 79dad80d4e80e77abf1cde87066b061bb53efe27 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 26 May 2024 20:20:22 +0700
Subject: [PATCH 08/27] ref: update implementation - Add `isEmpty` method to
 check to check the entire tree root and continue using `root == null` checks
 within recursive calls - Add default branch to switch statement

---
 .../datastructures/trees/SplayTree.java             | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 52e4f762317a..042836f54df1 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -47,6 +47,15 @@ public SplayTree() {
         root = null;
     }
 
+    /**
+     * Checks if the tree is empty.
+     *
+     * @return True if the tree is empty, otherwise false.
+     */
+    public boolean isEmpty() {
+        return root == null;
+    }
+
     /**
      * Zig operation.
      *
@@ -202,7 +211,7 @@ public boolean search(int key) {
      * @throws IllegalArgumentException If the tree is empty.
      */
     public void delete(int key) {
-        if (root == null) {
+        if (isEmpty()) {
             throw new IllegalArgumentException("Cannot delete from an empty tree");
         }
 
@@ -243,6 +252,8 @@ public List<Integer> traverse(TraverseOrder traverseOrder) {
         case POST_ORDER:
             postOrderRec(root, result);
             break;
+        default:
+            throw new IllegalArgumentException("Invalid traversal order: " + traverseOrder);
         }
         return result;
     }

From 9fbd1c0d65b2591106b1204149410c12930ca8ee Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 26 May 2024 20:25:19 +0700
Subject: [PATCH 09/27] chore(fix:style): fix Maven checkstyle Each variable
 declaration must be in its own statement. [MultipleVariableDeclarations]

---
 .../java/com/thealgorithms/datastructures/trees/SplayTree.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 042836f54df1..293b89a6d8e5 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -29,7 +29,8 @@ public class SplayTree {
 
     private static class Node {
         int key;
-        Node left, right;
+        Node left;
+        Node right;
 
         Node(int key) {
             this.key = key;

From 12effafefe4c96996ff2bf25facca88eb293e87c Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 26 May 2024 20:41:02 +0700
Subject: [PATCH 10/27] ref: add default pattern to switch statement

---
 .../thealgorithms/datastructures/trees/SplayTree.java  |  2 +-
 .../datastructures/trees/SplayTreeTest.java            | 10 ++++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 293b89a6d8e5..af06782e1bdf 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -304,5 +304,5 @@ private void postOrderRec(Node root, List<Integer> result) {
     /**
      * Enum to specify the order of traversal.
      */
-    public enum TraverseOrder { IN_ORDER, PRE_ORDER, POST_ORDER }
+    public enum TraverseOrder { IN_ORDER, PRE_ORDER, POST_ORDER, INVALID }
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index 6ea16b3570f8..929e23cb10de 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -9,6 +9,8 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -70,6 +72,14 @@ public void testInsertThrowsExceptionForDuplicateKeys(int value) {
         assertThrows(IllegalArgumentException.class, () -> tree.insert(value));
     }
 
+    @Test
+    public void testInvalidTraversalOrderExceptionMessage() {
+        SplayTree tree = createComplexTree();
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+                () -> tree.traverse(SplayTree.TraverseOrder.INVALID));
+        assertEquals("Invalid traversal order: INVALID", exception.getMessage());
+    }
+
     private static Stream<SplayTree.TraverseOrder> traversalOrders() {
         return Stream.of(SplayTree.TraverseOrder.IN_ORDER, SplayTree.TraverseOrder.PRE_ORDER, SplayTree.TraverseOrder.POST_ORDER);
     }

From d07f7bbc76d86892bd3d1b27e03c6ad212d74fe2 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 26 May 2024 20:43:08 +0700
Subject: [PATCH 11/27] chore: fix clang-format issue

---
 .../com/thealgorithms/datastructures/trees/SplayTreeTest.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index 929e23cb10de..83eb6cfd89ec 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -9,7 +9,6 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -75,8 +74,7 @@ public void testInsertThrowsExceptionForDuplicateKeys(int value) {
     @Test
     public void testInvalidTraversalOrderExceptionMessage() {
         SplayTree tree = createComplexTree();
-        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> tree.traverse(SplayTree.TraverseOrder.INVALID));
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> tree.traverse(SplayTree.TraverseOrder.INVALID));
         assertEquals("Invalid traversal order: INVALID", exception.getMessage());
     }
 

From d06940567d14f72acdf09af737a9600fb7b2de59 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Fri, 31 May 2024 08:55:31 +0700
Subject: [PATCH 12/27] ref: refactor SplayTree implementation - Implement 3
 traversal class of the `TreeTraversal` interface - Addjust tests to better
 cover code.

---
 .../datastructures/trees/SplayTree.java       | 124 +++++++++---------
 .../datastructures/trees/SplayTreeTest.java   |  60 +++------
 2 files changed, 81 insertions(+), 103 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index af06782e1bdf..251b1683083f 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -28,7 +28,7 @@
 public class SplayTree {
 
     private static class Node {
-        int key;
+        final int key;
         Node left;
         Node right;
 
@@ -41,14 +41,11 @@ private static class Node {
 
     private Node root;
 
-    /**
-     * Constructs an empty SplayTree.
-     */
     public SplayTree() {
         root = null;
     }
 
-    /**
+     /**
      * Checks if the tree is empty.
      *
      * @return True if the tree is empty, otherwise false.
@@ -135,29 +132,26 @@ private Node splay(Node root, int key) {
                 root = rotateRight(root);
             } // Zig-Zag case
             else if (root.left.key < key) {
-                // Recursive call to splay on grandchild
                 root.left.right = splay(root.left.right, key);
                 // Perform zag operation on parent
-                if (root.left.right != null) root.left = rotateLeft(root.left);
+                if (root.left.right != null) {
+                    root.left = rotateLeft(root.left);
+                }
             }
-
             return (root.left == null) ? root : rotateRight(root);
         } else {
             if (root.right == null) return root;
             // Zag-Zag case
             if (root.right.key > key) {
-                // Recursive call to splay on grandchild
                 root.right.left = splay(root.right.left, key);
                 // Perform zig operation on parent
                 if (root.right.left != null) root.right = rotateRight(root.right);
             } // Zag-Zig case
             else if (root.right.key < key) {
-                // Recursive call to splay on grandchild
                 root.right.right = splay(root.right.right, key);
                 // Perform zag operation on parent
                 root = rotateLeft(root);
             }
-
             return (root.right == null) ? root : rotateLeft(root);
         }
     }
@@ -228,8 +222,8 @@ public void delete(int key) {
         if (root.left == null) {
             root = root.right;
         } else {
-            Node temp = root;
             // Splay to bring the largest key in left subtree to root
+            Node temp = root;
             root = splay(root.left, key);
             root.right = temp.right;
         }
@@ -238,71 +232,73 @@ public void delete(int key) {
     /**
      * Perform a traversal of the SplayTree.
      *
-     * @param traverseOrder The order of traversal (IN_ORDER, PRE_ORDER, or POST_ORDER).
+     * @param traversal The type of traversal method.
      * @return A list containing the keys in the specified traversal order.
      */
-    public List<Integer> traverse(TraverseOrder traverseOrder) {
+    public List<Integer> traverse(TreeTraversal traversal) {
         List<Integer> result = new LinkedList<>();
-        switch (traverseOrder) {
-        case IN_ORDER:
-            inOrderRec(root, result);
-            break;
-        case PRE_ORDER:
-            preOrderRec(root, result);
-            break;
-        case POST_ORDER:
-            postOrderRec(root, result);
-            break;
-        default:
-            throw new IllegalArgumentException("Invalid traversal order: " + traverseOrder);
-        }
+        traversal.traverse(root, result);
         return result;
     }
 
-    /**
-     * Recursive function for in-order traversal.
-     *
-     * @param root   The root of the subtree to traverse.
-     * @param result The list to store the traversal result.
-     */
-    private void inOrderRec(Node root, List<Integer> result) {
-        if (root != null) {
-            inOrderRec(root.left, result);
-            result.add(root.key);
-            inOrderRec(root.right, result);
+    public interface TreeTraversal {
+        /**
+         * Recursive function for a specific order traversal.
+         *
+         * @param root   The root of the subtree to traverse.
+         * @param result The list to store the traversal result.
+         */
+        void traverse(Node root, List<Integer> result);
+    }
+
+    private static final class InOrderTraversal implements TreeTraversal {
+        private InOrderTraversal() {
+        }
+
+        public void traverse(Node root, List<Integer> result) {
+            if (root != null) {
+                traverse(root.left, result);
+                result.add(root.key);
+                traverse(root.right, result);
+            }
         }
     }
 
-    /**
-     * Recursive function for pre-order traversal.
-     *
-     * @param root   The root of the subtree to traverse.
-     * @param result The list to store the traversal result.
-     */
-    private void preOrderRec(Node root, List<Integer> result) {
-        if (root != null) {
-            result.add(root.key);
-            preOrderRec(root.left, result);
-            preOrderRec(root.right, result);
+    private static final class PreOrderTraversal implements TreeTraversal {
+        private PreOrderTraversal() {
+        }
+
+        public void traverse(Node root, List<Integer> result) {
+            if (root != null) {
+                result.add(root.key);
+                traverse(root.left, result);
+                traverse(root.right, result);
+            }
         }
     }
 
-    /**
-     * Recursive function for post-order traversal.
-     *
-     * @param root   The root of the subtree to traverse.
-     * @param result The list to store the traversal result.
-     */
-    private void postOrderRec(Node root, List<Integer> result) {
-        if (root != null) {
-            postOrderRec(root.left, result);
-            postOrderRec(root.right, result);
-            result.add(root.key);
+    private static final class PostOrderTraversal implements TreeTraversal {
+        private PostOrderTraversal() {
+        }
+
+        public void traverse(Node root, List<Integer> result) {
+            if (root != null) {
+                traverse(root.left, result);
+                traverse(root.right, result);
+                result.add(root.key);
+            }
         }
     }
 
-    /**
-     * Enum to specify the order of traversal.
-     */
-    public enum TraverseOrder { IN_ORDER, PRE_ORDER, POST_ORDER, INVALID }
+    public static TreeTraversal getInOrderTraversal() {
+        return new InOrderTraversal();
+    }
+
+    public static TreeTraversal getPreOrderTraversal() {
+        return new PreOrderTraversal();
+    }
+
+    public static TreeTraversal getPostOrderTraversal() {
+        return new PostOrderTraversal();
+    }
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index 83eb6cfd89ec..45b80e95001c 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -6,21 +6,18 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Stream;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
 public class SplayTreeTest {
+
     @ParameterizedTest
-    @MethodSource("traversalOrders")
-    public void testTraversal(SplayTree.TraverseOrder traverseOrder) {
+    @MethodSource("traversalStrategies")
+    public void testTraversal(SplayTree.TreeTraversal traversal, List<Integer> expected) {
         SplayTree tree = createComplexTree();
-        List<Integer> expected = getExpectedTraversalResult(traverseOrder);
-        List<Integer> result = tree.traverse(traverseOrder);
-
+        List<Integer> result = tree.traverse(traversal);
         assertEquals(expected, result);
     }
 
@@ -35,7 +32,6 @@ public void testSearch(int value) {
     @MethodSource("valuesToTest")
     public void testDelete(int value) {
         SplayTree tree = createComplexTree();
-
         assertTrue(tree.search(value));
         tree.delete(value);
         assertFalse(tree.search(value));
@@ -52,7 +48,6 @@ public void testSearchNonExistent(int value) {
     @MethodSource("nonExistentValues")
     public void testDeleteNonExistent(int value) {
         SplayTree tree = createComplexTree();
-
         tree.delete(value);
         assertFalse(tree.search(value));
     }
@@ -71,15 +66,16 @@ public void testInsertThrowsExceptionForDuplicateKeys(int value) {
         assertThrows(IllegalArgumentException.class, () -> tree.insert(value));
     }
 
-    @Test
-    public void testInvalidTraversalOrderExceptionMessage() {
-        SplayTree tree = createComplexTree();
-        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> tree.traverse(SplayTree.TraverseOrder.INVALID));
-        assertEquals("Invalid traversal order: INVALID", exception.getMessage());
+    @ParameterizedTest
+    @MethodSource("valuesToTest")
+    public void testSearchInEmptyTree(int value) {
+        SplayTree tree = new SplayTree();
+        assertFalse(tree.search(value));
     }
 
-    private static Stream<SplayTree.TraverseOrder> traversalOrders() {
-        return Stream.of(SplayTree.TraverseOrder.IN_ORDER, SplayTree.TraverseOrder.PRE_ORDER, SplayTree.TraverseOrder.POST_ORDER);
+    private static Stream<Object[]> traversalStrategies() {
+        return Stream.of(new Object[] {SplayTree.getInOrderTraversal(), Arrays.asList(1, 2, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18)}, new Object[] {SplayTree.getPreOrderTraversal(), Arrays.asList(18, 17, 16, 15, 13, 11, 10, 8, 7, 6, 2, 1, 5, 12)},
+            new Object[] {SplayTree.getPostOrderTraversal(), Arrays.asList(1, 5, 2, 6, 7, 8, 10, 12, 11, 13, 15, 16, 17, 18)});
     }
 
     private static Stream<Integer> valuesToTest() {
@@ -87,39 +83,25 @@ private static Stream<Integer> valuesToTest() {
     }
 
     private static Stream<Integer> nonExistentValues() {
-        return Stream.of(0, 11, 15);
-    }
-
-    private List<Integer> getExpectedTraversalResult(SplayTree.TraverseOrder traverseOrder) {
-        List<Integer> expected = new LinkedList<>();
-        switch (traverseOrder) {
-        case IN_ORDER:
-            expected.addAll(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-            break;
-        case PRE_ORDER:
-            expected.addAll(Arrays.asList(10, 9, 8, 7, 3, 1, 2, 5, 4, 6));
-            break;
-        case POST_ORDER:
-            expected.addAll(Arrays.asList(2, 1, 4, 6, 5, 3, 7, 8, 9, 10));
-            break;
-        default:
-            throw new IllegalArgumentException("Invalid traversal order: " + traverseOrder);
-        }
-        return expected;
+        return Stream.of(0, 21, 20);
     }
 
     private SplayTree createComplexTree() {
         SplayTree tree = new SplayTree();
+        tree.insert(10);
         tree.insert(5);
+        tree.insert(15);
         tree.insert(2);
         tree.insert(7);
         tree.insert(1);
-        tree.insert(4);
         tree.insert(6);
-        tree.insert(9);
-        tree.insert(3);
         tree.insert(8);
-        tree.insert(10);
+        tree.insert(12);
+        tree.insert(17);
+        tree.insert(11);
+        tree.insert(13);
+        tree.insert(16);
+        tree.insert(18);
         return tree;
     }
 }

From 0c44838d69fe952e4d3ad36ef4cf65ef9fd6b11c Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Fri, 31 May 2024 08:57:52 +0700
Subject: [PATCH 13/27] chore: fix clang-format issue

---
 .../java/com/thealgorithms/datastructures/trees/SplayTree.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 251b1683083f..e7d01363ac57 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -45,7 +45,7 @@ public SplayTree() {
         root = null;
     }
 
-     /**
+    /**
      * Checks if the tree is empty.
      *
      * @return True if the tree is empty, otherwise false.

From a0b9fd33b40e47cdf3f7afd3e0b57d928e28bf71 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Fri, 31 May 2024 09:28:17 +0700
Subject: [PATCH 14/27] chore(tests): update tests

---
 .../datastructures/trees/SplayTreeTest.java           | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index 45b80e95001c..8cecb97dac8d 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -74,16 +74,16 @@ public void testSearchInEmptyTree(int value) {
     }
 
     private static Stream<Object[]> traversalStrategies() {
-        return Stream.of(new Object[] {SplayTree.getInOrderTraversal(), Arrays.asList(1, 2, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18)}, new Object[] {SplayTree.getPreOrderTraversal(), Arrays.asList(18, 17, 16, 15, 13, 11, 10, 8, 7, 6, 2, 1, 5, 12)},
-            new Object[] {SplayTree.getPostOrderTraversal(), Arrays.asList(1, 5, 2, 6, 7, 8, 10, 12, 11, 13, 15, 16, 17, 18)});
+        return Stream.of(new Object[] {SplayTree.getInOrderTraversal(), Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18)}, new Object[] {SplayTree.getPreOrderTraversal(), Arrays.asList(18, 17, 16, 15, 13, 11, 9, 8, 7, 3, 2, 1, 5, 4, 6, 10, 12)},
+            new Object[] {SplayTree.getPostOrderTraversal(), Arrays.asList(1, 2, 4, 6, 5, 3, 7, 8, 10, 9, 12, 11, 13, 15, 16, 17, 18)});
     }
 
     private static Stream<Integer> valuesToTest() {
-        return Stream.of(1, 5, 10);
+        return Stream.of(1, 5, 10, 17, 8, 13, 6);
     }
 
     private static Stream<Integer> nonExistentValues() {
-        return Stream.of(0, 21, 20);
+        return Stream.of(0, 21, 20, 14);
     }
 
     private SplayTree createComplexTree() {
@@ -94,7 +94,10 @@ private SplayTree createComplexTree() {
         tree.insert(2);
         tree.insert(7);
         tree.insert(1);
+        tree.insert(4);
         tree.insert(6);
+        tree.insert(9);
+        tree.insert(3);
         tree.insert(8);
         tree.insert(12);
         tree.insert(17);

From 3935b058eb7c6b33974c549df665449c4b909a77 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sat, 1 Jun 2024 08:57:50 +0700
Subject: [PATCH 15/27] ref: refactor implementation - Make TreeTraversal
 interface implementations final - Update tests

---
 .../datastructures/trees/SplayTree.java            | 14 +++-----------
 .../datastructures/trees/SplayTreeTest.java        |  6 +++---
 2 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index e7d01363ac57..4495fcf67ce6 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -290,15 +290,7 @@ public void traverse(Node root, List<Integer> result) {
         }
     }
 
-    public static TreeTraversal getInOrderTraversal() {
-        return new InOrderTraversal();
-    }
-
-    public static TreeTraversal getPreOrderTraversal() {
-        return new PreOrderTraversal();
-    }
-
-    public static TreeTraversal getPostOrderTraversal() {
-        return new PostOrderTraversal();
-    }
+    public static final TreeTraversal PRE_ORDER = new PreOrderTraversal();
+    public static final TreeTraversal IN_ORDER = new InOrderTraversal();
+    public static final TreeTraversal POST_ORDER = new PostOrderTraversal();
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index 8cecb97dac8d..18889b0dad00 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -74,12 +74,12 @@ public void testSearchInEmptyTree(int value) {
     }
 
     private static Stream<Object[]> traversalStrategies() {
-        return Stream.of(new Object[] {SplayTree.getInOrderTraversal(), Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18)}, new Object[] {SplayTree.getPreOrderTraversal(), Arrays.asList(18, 17, 16, 15, 13, 11, 9, 8, 7, 3, 2, 1, 5, 4, 6, 10, 12)},
-            new Object[] {SplayTree.getPostOrderTraversal(), Arrays.asList(1, 2, 4, 6, 5, 3, 7, 8, 10, 9, 12, 11, 13, 15, 16, 17, 18)});
+        return Stream.of(new Object[] {SplayTree.IN_ORDER, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18)}, new Object[] {SplayTree.PRE_ORDER, Arrays.asList(18, 17, 16, 15, 13, 11, 9, 8, 7, 3, 2, 1, 5, 4, 6, 10, 12)},
+            new Object[] {SplayTree.POST_ORDER, Arrays.asList(1, 2, 4, 6, 5, 3, 7, 8, 10, 9, 12, 11, 13, 15, 16, 17, 18)});
     }
 
     private static Stream<Integer> valuesToTest() {
-        return Stream.of(1, 5, 10, 17, 8, 13, 6);
+        return Stream.of(1, 5, 10, 17, 8, 13, 6, 17, 4, 11, 9, 2, 18, 3, 16, 7, 12);
     }
 
     private static Stream<Integer> nonExistentValues() {

From 95dc5c9441d18b215c45eb9421cae4ff9b2a4308 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sat, 15 Jun 2024 15:17:24 +0700
Subject: [PATCH 16/27] chore(fix[check-style]): use braces in `if` statement

---
 .../datastructures/trees/SplayTree.java       | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 4495fcf67ce6..75fd7c75f485 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -120,10 +120,14 @@ private Node rotateLeft(Node x) {
      * @return The new root of the splayed subtree.
      */
     private Node splay(Node root, int key) {
-        if (root == null || root.key == key) return root;
+        if (root == null || root.key == key) {
+            return root;
+        }
 
         if (root.key > key) {
-            if (root.left == null) return root;
+            if (root.left == null) {
+                return root;
+            }
             // Zig-Zig case
             if (root.left.key > key) {
                 // Recursive call to splay on grandchild
@@ -140,12 +144,16 @@ else if (root.left.key < key) {
             }
             return (root.left == null) ? root : rotateRight(root);
         } else {
-            if (root.right == null) return root;
+            if (root.right == null) {
+                return root;
+            }
             // Zag-Zag case
             if (root.right.key > key) {
                 root.right.left = splay(root.right.left, key);
                 // Perform zig operation on parent
-                if (root.right.left != null) root.right = rotateRight(root.right);
+                if (root.right.left != null) {
+                    root.right = rotateRight(root.right);
+                }
             } // Zag-Zig case
             else if (root.right.key < key) {
                 root.right.right = splay(root.right.right, key);
@@ -175,7 +183,9 @@ public void insert(int key) {
      * @throws IllegalArgumentException If the key to be inserted already exists in the subtree.
      */
     private Node insertRec(Node root, int key) {
-        if (root == null) return new Node(key);
+        if (root == null) {
+            return new Node(key);
+        }
 
         if (key < root.key) {
             root.left = insertRec(root.left, key);

From e5a39ae306fafdf8e3a4202989122fcf438eccb2 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 30 Jun 2024 14:40:00 +0700
Subject: [PATCH 17/27] chore: update splaytree initialization

---
 .../thealgorithms/datastructures/trees/SplayTreeTest.java | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index 18889b0dad00..b76153b5455d 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -74,8 +74,8 @@ public void testSearchInEmptyTree(int value) {
     }
 
     private static Stream<Object[]> traversalStrategies() {
-        return Stream.of(new Object[] {SplayTree.IN_ORDER, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18)}, new Object[] {SplayTree.PRE_ORDER, Arrays.asList(18, 17, 16, 15, 13, 11, 9, 8, 7, 3, 2, 1, 5, 4, 6, 10, 12)},
-            new Object[] {SplayTree.POST_ORDER, Arrays.asList(1, 2, 4, 6, 5, 3, 7, 8, 10, 9, 12, 11, 13, 15, 16, 17, 18)});
+        return Stream.of(new Object[] {SplayTree.IN_ORDER, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20)}, new Object[] {SplayTree.PRE_ORDER, Arrays.asList(20, 17, 14, 13, 11, 9, 8, 7, 3, 2, 1, 5, 4, 6, 10, 12, 15, 16, 18)},
+            new Object[] {SplayTree.POST_ORDER, Arrays.asList(1, 2, 4, 6, 5, 3, 7, 8, 10, 9, 12, 11, 13, 16, 15, 14, 18, 17, 20)});
     }
 
     private static Stream<Integer> valuesToTest() {
@@ -83,7 +83,7 @@ private static Stream<Integer> valuesToTest() {
     }
 
     private static Stream<Integer> nonExistentValues() {
-        return Stream.of(0, 21, 20, 14);
+        return Stream.of(0, 21, 22, 23);
     }
 
     private SplayTree createComplexTree() {
@@ -105,6 +105,8 @@ private SplayTree createComplexTree() {
         tree.insert(13);
         tree.insert(16);
         tree.insert(18);
+        tree.insert(14);
+        tree.insert(20);
         return tree;
     }
 }

From d2546e736da86ebf4dd7f834eeb54300ff45530c Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 30 Jun 2024 15:01:33 +0700
Subject: [PATCH 18/27] ref: update tests

---
 .../datastructures/trees/SplayTreeTest.java   | 41 ++++++++++---------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index b76153b5455d..bdb5b56bc020 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -74,39 +74,40 @@ public void testSearchInEmptyTree(int value) {
     }
 
     private static Stream<Object[]> traversalStrategies() {
-        return Stream.of(new Object[] {SplayTree.IN_ORDER, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20)}, new Object[] {SplayTree.PRE_ORDER, Arrays.asList(20, 17, 14, 13, 11, 9, 8, 7, 3, 2, 1, 5, 4, 6, 10, 12, 15, 16, 18)},
-            new Object[] {SplayTree.POST_ORDER, Arrays.asList(1, 2, 4, 6, 5, 3, 7, 8, 10, 9, 12, 11, 13, 16, 15, 14, 18, 17, 20)});
+        return Stream.of(new Object[] {SplayTree.IN_ORDER, Arrays.asList(5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90)}, new Object[] {SplayTree.PRE_ORDER, Arrays.asList(15, 5, 10, 80, 70, 45, 25, 20, 35, 30, 40, 55, 50, 65, 60, 75, 90, 85)},
+            new Object[] {SplayTree.POST_ORDER, Arrays.asList(10, 5, 20, 30, 40, 35, 25, 50, 60, 65, 55, 45, 75, 70, 85, 90, 80, 15)});
     }
 
     private static Stream<Integer> valuesToTest() {
-        return Stream.of(1, 5, 10, 17, 8, 13, 6, 17, 4, 11, 9, 2, 18, 3, 16, 7, 12);
+        return Stream.of(5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90);
     }
 
     private static Stream<Integer> nonExistentValues() {
-        return Stream.of(0, 21, 22, 23);
+        return Stream.of(0, 100, 42, 58);
     }
 
     private SplayTree createComplexTree() {
         SplayTree tree = new SplayTree();
+
+        tree.insert(50);
+        tree.insert(30);
+        tree.insert(40);
+        tree.insert(70);
+        tree.insert(60);
+        tree.insert(20);
+        tree.insert(80);
         tree.insert(10);
+        tree.insert(25);
+        tree.insert(35);
+        tree.insert(45);
+        tree.insert(55);
+        tree.insert(65);
+        tree.insert(75);
+        tree.insert(85);
         tree.insert(5);
+        tree.insert(90);
         tree.insert(15);
-        tree.insert(2);
-        tree.insert(7);
-        tree.insert(1);
-        tree.insert(4);
-        tree.insert(6);
-        tree.insert(9);
-        tree.insert(3);
-        tree.insert(8);
-        tree.insert(12);
-        tree.insert(17);
-        tree.insert(11);
-        tree.insert(13);
-        tree.insert(16);
-        tree.insert(18);
-        tree.insert(14);
-        tree.insert(20);
+
         return tree;
     }
 }

From 16df17c986d4c613628294db895a0baccba7953f Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 30 Jun 2024 15:11:38 +0700
Subject: [PATCH 19/27] chore: add tests `testZigZagCaseWithNullChild()`

---
 .../datastructures/trees/SplayTreeTest.java        | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index bdb5b56bc020..1ff540145623 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -8,6 +8,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -110,4 +111,17 @@ private SplayTree createComplexTree() {
 
         return tree;
     }
+
+    @Test
+    public void testZigZagCaseWithNullChild() {
+        SplayTree tree = new SplayTree();
+        tree.insert(30);
+        tree.insert(10);
+        tree.insert(20);
+        tree.insert(15);
+
+        assertTrue(tree.search(15));
+
+        assertEquals(Arrays.asList(10, 15, 20, 30), tree.traverse(SplayTree.IN_ORDER));
+    }
 }

From c9f0696b5b1e601e6f64691d65551163c315916c Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sat, 31 Aug 2024 10:39:28 +0700
Subject: [PATCH 20/27] ref: improve splay tree

---
 .../datastructures/trees/SplayTree.java       | 194 ++++++++----------
 .../datastructures/trees/SplayTreeTest.java   |   4 +-
 2 files changed, 92 insertions(+), 106 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 75fd7c75f485..f761e665c740 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -5,46 +5,27 @@
 
 /**
  * Implementation of a Splay Tree data structure.
- *
- * <p>
+ * 
  * A splay tree is a self-adjusting binary search tree with the additional property
  * that recently accessed elements are quick to access again. It performs basic
  * operations such as insertion, deletion, and searching in O(log n) amortized time,
  * where n is the number of elements in the tree.
- * </p>
- *
- * <p>
+ * 
  * The key feature of splay trees is the splay operation, which moves a node closer
  * to the root of the tree when it is accessed. This operation helps to maintain
  * good balance and improves the overall performance of the tree. After performing
  * a splay operation, the accessed node becomes the new root of the tree.
- * </p>
- *
- * <p>
+ * 
  * Splay trees have applications in various areas, including caching, network routing,
  * and dynamic optimality analysis.
- * </p>
  */
 public class SplayTree {
-
-    private static class Node {
-        final int key;
-        Node left;
-        Node right;
-
-        Node(int key) {
-            this.key = key;
-            left = null;
-            right = null;
-        }
-    }
+    public static final TreeTraversal PRE_ORDER = new PreOrderTraversal();
+    public static final TreeTraversal IN_ORDER = new InOrderTraversal();
+    public static final TreeTraversal POST_ORDER = new PostOrderTraversal();
 
     private Node root;
 
-    public SplayTree() {
-        root = null;
-    }
-
     /**
      * Checks if the tree is empty.
      *
@@ -54,6 +35,69 @@ public boolean isEmpty() {
         return root == null;
     }
 
+    /**
+     * Insert a key into the SplayTree.
+     *
+     * @param key The key to insert.
+     */
+    public final void insert(int key) {
+        root = insertRec(root, key);
+        root = splay(root, key);
+    }
+
+    /**
+     * Search for a key in the SplayTree.
+     *
+     * @param key The key to search for.
+     * @return True if the key is found, otherwise false.
+     */
+    public boolean search(int key) {
+        root = splay(root, key);
+        return root != null && root.key == key;
+    }
+
+    /**
+     * Deletes a key from the SplayTree.
+     *
+     * @param key The key to delete.
+     * @throws IllegalArgumentException If the tree is empty.
+     */
+    public final void delete(int key) {
+        if (isEmpty()) {
+            throw new EmptyTreeException("Cannot delete from an empty tree");
+        }
+
+        // Splay the tree with the key to be deleted
+        root = splay(root, key);
+
+        // If the key is not found at the root, return without deleting
+        if (root.key != key) {
+            return;
+        }
+
+        // Handle deletion
+        if (root.left == null) {
+            root = root.right;
+        } else {
+            // Splay to bring the largest key in left subtree to root
+            Node temp = root;
+            root = splay(root.left, key);
+            root.right = temp.right;
+        }
+    }
+
+    /**
+     * Perform a traversal of the SplayTree.
+     *
+     * @param traversal The type of traversal method.
+     * @return A list containing the keys in the specified traversal order.
+     */
+    public List<Integer> traverse(TreeTraversal traversal) {
+        List<Integer> result = new LinkedList<>();
+        traversal.traverse(root, result);
+        return result;
+    }
+
     /**
      * Zig operation.
      *
@@ -119,7 +163,7 @@ private Node rotateLeft(Node x) {
      * @param key  The key to splay around.
      * @return The new root of the splayed subtree.
      */
-    private Node splay(Node root, int key) {
+    private final Node splay(Node root, int key) {
         if (root == null || root.key == key) {
             return root;
         }
@@ -130,14 +174,10 @@ private Node splay(Node root, int key) {
             }
             // Zig-Zig case
             if (root.left.key > key) {
-                // Recursive call to splay on grandchild
                 root.left.left = splay(root.left.left, key);
-                // Perform zig operation on parent
                 root = rotateRight(root);
-            } // Zig-Zag case
-            else if (root.left.key < key) {
+            } else if (root.left.key < key) {
                 root.left.right = splay(root.left.right, key);
-                // Perform zag operation on parent
                 if (root.left.right != null) {
                     root.left = rotateLeft(root.left);
                 }
@@ -150,39 +190,18 @@ else if (root.left.key < key) {
             // Zag-Zag case
             if (root.right.key > key) {
                 root.right.left = splay(root.right.left, key);
-                // Perform zig operation on parent
                 if (root.right.left != null) {
                     root.right = rotateRight(root.right);
                 }
-            } // Zag-Zig case
-            else if (root.right.key < key) {
+            } else if (root.right.key < key) {
                 root.right.right = splay(root.right.right, key);
-                // Perform zag operation on parent
                 root = rotateLeft(root);
             }
             return (root.right == null) ? root : rotateLeft(root);
         }
     }
 
-    /**
-     * Insert a key into the SplayTree.
-     *
-     * @param key The key to insert.
-     */
-    public void insert(int key) {
-        root = insertRec(root, key);
-        root = splay(root, key);
-    }
-
-    /**
-     * Recursive function to insert a key into a subtree.
-     *
-     * @param root The root of the subtree to insert the key into.
-     * @param key  The key to insert.
-     * @return The root of the modified subtree after insertion.
-     * @throws IllegalArgumentException If the key to be inserted already exists in the subtree.
-     */
-    private Node insertRec(Node root, int key) {
+    private final Node insertRec(Node root, int key) {
         if (root == null) {
             return new Node(key);
         }
@@ -192,65 +211,36 @@ private Node insertRec(Node root, int key) {
         } else if (key > root.key) {
             root.right = insertRec(root.right, key);
         } else {
-            throw new IllegalArgumentException("Duplicate key: " + key);
+            throw new DuplicateKeyException("Duplicate key: " + key);
         }
 
         return root;
     }
 
-    /**
-     * Search for a key in the SplayTree.
-     *
-     * @param key The key to search for.
-     * @return True if the key is found, otherwise false.
-     */
-    public boolean search(int key) {
-        root = splay(root, key);
-        return root != null && root.key == key;
+    public static class EmptyTreeException extends RuntimeException {
+        public EmptyTreeException(String message) {
+            super(message);
+        }
     }
 
-    /**
-     * Deletes a key from the SplayTree.
-     *
-     * @param key The key to delete.
-     * @throws IllegalArgumentException If the tree is empty.
-     */
-    public void delete(int key) {
-        if (isEmpty()) {
-            throw new IllegalArgumentException("Cannot delete from an empty tree");
+    public static class DuplicateKeyException extends RuntimeException {
+        public DuplicateKeyException(String message) {
+            super(message);
         }
+    }
 
-        // Splay the tree with the key to be deleted
-        root = splay(root, key);
-
-        // If the key is not found at the root, return without deleting
-        if (root.key != key) {
-            return;
-        }
+    private static class Node {
+        final int key;
+        Node left;
+        Node right;
 
-        // Handle deletion
-        if (root.left == null) {
-            root = root.right;
-        } else {
-            // Splay to bring the largest key in left subtree to root
-            Node temp = root;
-            root = splay(root.left, key);
-            root.right = temp.right;
+        Node(int key) {
+            this.key = key;
+            left = null;
+            right = null;
         }
     }
 
-    /**
-     * Perform a traversal of the SplayTree.
-     *
-     * @param traversal The type of traversal method.
-     * @return A list containing the keys in the specified traversal order.
-     */
-    public List<Integer> traverse(TreeTraversal traversal) {
-        List<Integer> result = new LinkedList<>();
-        traversal.traverse(root, result);
-        return result;
-    }
-
     public interface TreeTraversal {
         /**
          * Recursive function for a specific order traversal.
@@ -299,8 +289,4 @@ public void traverse(Node root, List<Integer> result) {
             }
         }
     }
-
-    public static final TreeTraversal PRE_ORDER = new PreOrderTraversal();
-    public static final TreeTraversal IN_ORDER = new InOrderTraversal();
-    public static final TreeTraversal POST_ORDER = new PostOrderTraversal();
 }
diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index 1ff540145623..ee87206b585d 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -57,14 +57,14 @@ public void testDeleteNonExistent(int value) {
     @MethodSource("valuesToTest")
     public void testDeleteThrowsExceptionForEmptyTree(int value) {
         SplayTree tree = new SplayTree();
-        assertThrows(IllegalArgumentException.class, () -> tree.delete(value));
+        assertThrows(SplayTree.EmptyTreeException.class, () -> tree.delete(value));
     }
 
     @ParameterizedTest
     @MethodSource("valuesToTest")
     public void testInsertThrowsExceptionForDuplicateKeys(int value) {
         SplayTree tree = createComplexTree();
-        assertThrows(IllegalArgumentException.class, () -> tree.insert(value));
+        assertThrows(SplayTree.DuplicateKeyException.class, () -> tree.insert(value));
     }
 
     @ParameterizedTest

From 7125270c8ae2467c0ab7d85a6c1d0b577035d37a Mon Sep 17 00:00:00 2001
From: TruongNhanNguyen <TruongNhanNguyen@users.noreply.github.com>
Date: Sat, 31 Aug 2024 03:39:50 +0000
Subject: [PATCH 21/27] Update directory

---
 DIRECTORY.md | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index c033fe307ab2..388688756226 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -193,6 +193,7 @@
               * [RedBlackBST](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/trees/RedBlackBST.java)
               * [SameTreesCheck](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/trees/SameTreesCheck.java)
               * [SegmentTree](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/trees/SegmentTree.java)
+              * [SplayTree](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java)
               * [TreeRandomNode](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/trees/TreeRandomNode.java)
               * [TrieImp](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/trees/TrieImp.java)
               * [VerticalOrderTraversal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/trees/VerticalOrderTraversal.java)
@@ -528,8 +529,8 @@
             * [TimSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/TimSort.java)
             * [TopologicalSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/TopologicalSort.java)
             * [TreeSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/TreeSort.java)
-            * [WiggleSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/WiggleSort.java)
             * [WaveSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/WaveSort.java)
+            * [WiggleSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/WiggleSort.java)
           * stacks
             * [BalancedBrackets](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/BalancedBrackets.java)
             * [DecimalToAnyUsingStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/DecimalToAnyUsingStack.java)
@@ -680,6 +681,7 @@
               * [PostOrderTraversalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/PostOrderTraversalTest.java)
               * [PreOrderTraversalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/PreOrderTraversalTest.java)
               * [SameTreesCheckTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/SameTreesCheckTest.java)
+              * [SplayTreeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java)
               * [TreeTestUtils](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/TreeTestUtils.java)
               * [VerticalOrderTraversalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/VerticalOrderTraversalTest.java)
               * [ZigzagTraversalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/ZigzagTraversalTest.java)
@@ -761,6 +763,7 @@
             * [LongDivisionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/LongDivisionTest.java)
             * [LucasSeriesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/LucasSeriesTest.java)
             * [MatrixRankTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/MatrixRankTest.java)
+            * [MatrixUtilTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/MatrixUtilTest.java)
             * [MaxValueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/MaxValueTest.java)
             * [MeansTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/MeansTest.java)
             * [MedianTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/MedianTest.java)
@@ -831,6 +834,7 @@
             * [NextFitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/NextFitTest.java)
             * [PasswordGenTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/PasswordGenTest.java)
             * [SieveOfEratosthenesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/SieveOfEratosthenesTest.java)
+            * [StringMatchFiniteAutomataTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java)
             * [TestPrintMatrixInSpiralOrder](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TestPrintMatrixInSpiralOrder.java)
             * [TwoPointersTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TwoPointersTest.java)
             * [WorstFitCPUTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/WorstFitCPUTest.java)
@@ -857,6 +861,7 @@
           * sorts
             * [BeadSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BeadSortTest.java)
             * [BinaryInsertionSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BinaryInsertionSortTest.java)
+            * [BitonicSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BitonicSortTest.java)
             * [BogoSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BogoSortTest.java)
             * [BubbleSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BubbleSortTest.java)
             * [BucketSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BucketSortTest.java)
@@ -875,8 +880,8 @@
             * [OddEvenSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/OddEvenSortTest.java)
             * [PancakeSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/PancakeSortTest.java)
             * [QuickSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/QuickSortTest.java)
-            * [SelectionSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SelectionSortTest.java)
             * [SelectionSortRecursiveTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SelectionSortRecursiveTest.java)
+            * [SelectionSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SelectionSortTest.java)
             * [ShellSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/ShellSortTest.java)
             * [SimpleSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SimpleSortTest.java)
             * [SlowSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SlowSortTest.java)
@@ -884,11 +889,12 @@
             * [SortUtilsRandomGeneratorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SortUtilsRandomGeneratorTest.java)
             * [SortUtilsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SortUtilsTest.java)
             * [StrandSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/StrandSortTest.java)
+            * [SwapSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SwapSortTest.java)
             * [TimSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/TimSortTest.java)
             * [TopologicalSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/TopologicalSortTest.java)
             * [TreeSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/TreeSortTest.java)
-            * [WiggleSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/WiggleSortTest.java)
             * [WaveSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/WaveSortTest.java)
+            * [WiggleSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/WiggleSortTest.java)
           * stacks
             * [StackPostfixNotationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/StackPostfixNotationTest.java)
           * strings

From 8306158c3a948ed8a46c73754c45698f10a29902 Mon Sep 17 00:00:00 2001
From: TruongNhanNguyen <TruongNhanNguyen@users.noreply.github.com>
Date: Sat, 31 Aug 2024 03:53:56 +0000
Subject: [PATCH 22/27] Update directory

---
 DIRECTORY.md | 92 ++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 74 insertions(+), 18 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 0a86bc81a815..bbcee88e52be 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -53,6 +53,7 @@
             * [SimpleSubCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/SimpleSubCipher.java)
             * [Vigenere](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/Vigenere.java)
           * conversions
+            * [AffineConverter](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/AffineConverter.java)
             * [AnyBaseToAnyBase](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/AnyBaseToAnyBase.java)
             * [AnyBaseToDecimal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/AnyBaseToDecimal.java)
             * [AnytoAny](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/AnytoAny.java)
@@ -61,7 +62,7 @@
             * [BinaryToOctal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/BinaryToOctal.java)
             * [DecimalToAnyBase](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/DecimalToAnyBase.java)
             * [DecimalToBinary](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/DecimalToBinary.java)
-            * [DecimalToHexaDecimal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/DecimalToHexaDecimal.java)
+            * [DecimalToHexadecimal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/DecimalToHexadecimal.java)
             * [DecimalToOctal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/DecimalToOctal.java)
             * [HexaDecimalToBinary](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/HexaDecimalToBinary.java)
             * [HexaDecimalToDecimal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/HexaDecimalToDecimal.java)
@@ -73,6 +74,8 @@
             * [RgbHsvConversion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/RgbHsvConversion.java)
             * [RomanToInteger](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/RomanToInteger.java)
             * [TurkishToLatinConversion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/TurkishToLatinConversion.java)
+            * [UnitConversions](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/UnitConversions.java)
+            * [UnitsConverter](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/UnitsConverter.java)
           * datastructures
             * bags
               * [Bag](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/bags/Bag.java)
@@ -99,12 +102,13 @@
             * graphs
               * [AStar](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/AStar.java)
               * [BellmanFord](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java)
-              * [BipartiteGrapfDFS](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/BipartiteGrapfDFS.java)
+              * [BipartiteGraphDFS](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/BipartiteGraphDFS.java)
               * [BoruvkaAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/BoruvkaAlgorithm.java)
               * [ConnectedComponent](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/ConnectedComponent.java)
               * [Cycles](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/Cycles.java)
-              * [DIJSKSTRAS ALGORITHM](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/DIJSKSTRAS_ALGORITHM.java)
+              * [DijkstraAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithm.java)
               * [FloydWarshall](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/FloydWarshall.java)
+              * [FordFulkerson](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/FordFulkerson.java)
               * [Graphs](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/Graphs.java)
               * [HamiltonianCycle](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/HamiltonianCycle.java)
               * [KahnsAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/KahnsAlgorithm.java)
@@ -122,7 +126,6 @@
                 * [HashMapCuckooHashing](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/HashMapCuckooHashing.java)
                 * [Intersection](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/Intersection.java)
                 * [LinearProbingHashMap](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/LinearProbingHashMap.java)
-                * [Main](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/Main.java)
                 * [MainCuckooHashing](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/MainCuckooHashing.java)
                 * [MajorityElement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/MajorityElement.java)
                 * [Map](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/Map.java)
@@ -142,7 +145,7 @@
               * [CreateAndDetectLoop](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/CreateAndDetectLoop.java)
               * [CursorLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/CursorLinkedList.java)
               * [DoublyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/DoublyLinkedList.java)
-              * [MergeKSortedLinkedlist](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/MergeKSortedLinkedlist.java)
+              * [MergeKSortedLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/MergeKSortedLinkedList.java)
               * [MergeSortedArrayList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/MergeSortedArrayList.java)
               * [MergeSortedSinglyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/MergeSortedSinglyLinkedList.java)
               * [QuickSortLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/QuickSortLinkedList.java)
@@ -155,14 +158,15 @@
             * [Node](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/Node.java)
             * queues
               * [CircularQueue](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/CircularQueue.java)
-              * [Deques](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/Deques.java)
+              * [Deque](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/Deque.java)
               * [GenericArrayListQueue](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/GenericArrayListQueue.java)
               * [LinkedQueue](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/LinkedQueue.java)
               * [PriorityQueues](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/PriorityQueues.java)
-              * [Queues](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/Queues.java)
+              * [Queue](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/Queue.java)
             * stacks
               * [NodeStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java)
               * [ReverseStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/stacks/ReverseStack.java)
+              * [Stack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/stacks/Stack.java)
               * [StackArray](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/stacks/StackArray.java)
               * [StackArrayList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/stacks/StackArrayList.java)
               * [StackOfLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/stacks/StackOfLinkedList.java)
@@ -227,7 +231,6 @@
             * [EditDistance](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/EditDistance.java)
             * [EggDropping](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/EggDropping.java)
             * [Fibonacci](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/Fibonacci.java)
-            * [FordFulkerson](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/FordFulkerson.java)
             * [KadaneAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithm.java)
             * [Knapsack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/Knapsack.java)
             * [KnapsackMemoization](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/KnapsackMemoization.java)
@@ -292,6 +295,7 @@
             * [DistanceFormula](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/DistanceFormula.java)
             * [DudeneyNumber](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/DudeneyNumber.java)
             * [EulerMethod](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/EulerMethod.java)
+            * [EulersFunction](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/EulersFunction.java)
             * [Factorial](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/Factorial.java)
             * [FactorialRecursion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FactorialRecursion.java)
             * [FastInverseSqrt](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FastInverseSqrt.java)
@@ -357,6 +361,7 @@
             * [ReverseNumber](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/ReverseNumber.java)
             * [RomanNumeralUtil](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/RomanNumeralUtil.java)
             * [SecondMinMax](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/SecondMinMax.java)
+            * [SieveOfEratosthenes](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/SieveOfEratosthenes.java)
             * [SimpsonIntegration](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/SimpsonIntegration.java)
             * [SquareFreeInteger](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java)
             * [SquareRootWithBabylonianMethod](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/SquareRootWithBabylonianMethod.java)
@@ -412,15 +417,13 @@
             * [CRCAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/CRCAlgorithm.java)
             * [Damm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/Damm.java)
             * [Dijkstra](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/Dijkstra.java)
-            * [EulersFunction](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/EulersFunction.java)
             * [FibbonaciSeries](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/FibbonaciSeries.java)
             * [FloydTriangle](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/FloydTriangle.java)
-            * [GuassLegendre](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/GuassLegendre.java)
+            * [GaussLegendre](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/GaussLegendre.java)
             * [HappyNumbersSeq](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/HappyNumbersSeq.java)
             * [Huffman](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/Huffman.java)
             * [Implementing auto completing features using trie](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java)
             * [InsertDeleteInArray](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/InsertDeleteInArray.java)
-            * [KMP](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/KMP.java)
             * [KochSnowflake](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/KochSnowflake.java)
             * [Krishnamurthy](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/Krishnamurthy.java)
             * [LinearCongruentialGenerator](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/LinearCongruentialGenerator.java)
@@ -436,12 +439,10 @@
             * [PerlinNoise](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/PerlinNoise.java)
             * [PrintAMatrixInSpiralOrder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/PrintAMatrixInSpiralOrder.java)
             * [QueueUsingTwoStacks](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/QueueUsingTwoStacks.java)
-            * [RabinKarp](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/RabinKarp.java)
             * [RemoveDuplicateFromString](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/RemoveDuplicateFromString.java)
             * [ReturnSubsequence](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/ReturnSubsequence.java)
             * [ReverseStackUsingRecursion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/ReverseStackUsingRecursion.java)
             * [RotateMatrixBy90Degrees](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/RotateMatrixBy90Degrees.java)
-            * [SieveOfEratosthenes](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/SieveOfEratosthenes.java)
             * [SkylineProblem](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/SkylineProblem.java)
             * [StringMatchFiniteAutomata](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/StringMatchFiniteAutomata.java)
             * [Sudoku](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/others/Sudoku.java)
@@ -554,14 +555,16 @@
             * [HammingDistance](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/HammingDistance.java)
             * [HorspoolSearch](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/HorspoolSearch.java)
             * [Isomorphic](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/Isomorphic.java)
+            * [KMP](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/KMP.java)
             * [LetterCombinationsOfPhoneNumber](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/LetterCombinationsOfPhoneNumber.java)
-            * [LongestNonRepeativeSubstring](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/LongestNonRepeativeSubstring.java)
+            * [LongestNonRepetitiveSubstring](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/LongestNonRepetitiveSubstring.java)
             * [LongestPalindromicSubstring](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/LongestPalindromicSubstring.java)
             * [Lower](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/Lower.java)
             * [MyAtoi](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/MyAtoi.java)
             * [Palindrome](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/Palindrome.java)
             * [Pangram](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/Pangram.java)
             * [PermuteString](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/PermuteString.java)
+            * [RabinKarp](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/RabinKarp.java)
             * [ReverseString](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/ReverseString.java)
             * [ReverseStringRecursive](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/ReverseStringRecursive.java)
             * [ReverseWordsInString](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/ReverseWordsInString.java)
@@ -583,6 +586,7 @@
             * [FloodFillTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/FloodFillTest.java)
             * [MazeRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/MazeRecursionTest.java)
             * [MColoringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/MColoringTest.java)
+            * [NQueensTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/NQueensTest.java)
             * [ParenthesesGeneratorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/ParenthesesGeneratorTest.java)
             * [PermutationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/PermutationTest.java)
             * [PowerSumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/backtracking/PowerSumTest.java)
@@ -610,10 +614,14 @@
             * [SimpleSubCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/SimpleSubCipherTest.java)
             * [VigenereTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/VigenereTest.java)
           * conversions
+            * [AnyBaseToDecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/AnyBaseToDecimalTest.java)
             * [BinaryToDecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/BinaryToDecimalTest.java)
             * [BinaryToHexadecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/BinaryToHexadecimalTest.java)
             * [BinaryToOctalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/BinaryToOctalTest.java)
-            * [DecimalToHexaDecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/DecimalToHexaDecimalTest.java)
+            * [DecimalToAnyBaseTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/DecimalToAnyBaseTest.java)
+            * [DecimalToBinaryTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/DecimalToBinaryTest.java)
+            * [DecimalToHexadecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/DecimalToHexadecimalTest.java)
+            * [DecimalToOctalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/DecimalToOctalTest.java)
             * [HexaDecimalToBinaryTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/HexaDecimalToBinaryTest.java)
             * [HexaDecimalToDecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/HexaDecimalToDecimalTest.java)
             * [HexToOctTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/HexToOctTest.java)
@@ -622,7 +630,11 @@
             * [OctalToDecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/OctalToDecimalTest.java)
             * [OctalToHexadecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/OctalToHexadecimalTest.java)
             * [RomanToIntegerTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/RomanToIntegerTest.java)
+            * [UnitConversionsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/UnitConversionsTest.java)
+            * [UnitsConverterTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/UnitsConverterTest.java)
           * datastructures
+            * bag
+              * [BagTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/bag/BagTest.java)
             * bloomfilter
               * [BloomFilterTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/bloomfilter/BloomFilterTest.java)
             * buffers
@@ -640,8 +652,12 @@
               * [TwoPSetTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/crdt/TwoPSetTest.java)
             * disjointsetunion
               * [DisjointSetUnionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/disjointsetunion/DisjointSetUnionTest.java)
+            * dynamicarray
+              * [DynamicArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/dynamicarray/DynamicArrayTest.java)
             * graphs
               * [BoruvkaAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/BoruvkaAlgorithmTest.java)
+              * [DijkstraAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithmTest.java)
+              * [FordFulkersonTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/FordFulkersonTest.java)
               * [HamiltonianCycleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/HamiltonianCycleTest.java)
               * [KosarajuTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/KosarajuTest.java)
               * [TarjansAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithmTest.java)
@@ -650,6 +666,7 @@
               * hashing
                 * [GenericHashMapUsingArrayListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/hashmap/hashing/GenericHashMapUsingArrayListTest.java)
                 * [GenericHashMapUsingArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/hashmap/hashing/GenericHashMapUsingArrayTest.java)
+                * [HashMapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/hashmap/hashing/HashMapTest.java)
                 * [LinearProbingHashMapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/hashmap/hashing/LinearProbingHashMapTest.java)
                 * [MajorityElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/hashmap/hashing/MajorityElementTest.java)
                 * [MapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/hashmap/hashing/MapTest.java)
@@ -658,14 +675,23 @@
               * [FibonacciHeapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/FibonacciHeapTest.java)
               * [LeftistHeapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/LeftistHeapTest.java)
             * lists
+              * [CircleLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/CircleLinkedListTest.java)
               * [QuickSortLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/QuickSortLinkedListTest.java)
               * [ReverseKGroupTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/ReverseKGroupTest.java)
               * [RotateSinglyLinkedListsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/RotateSinglyLinkedListsTest.java)
               * [SinglyLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/SinglyLinkedListTest.java)
               * [SkipListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/SkipListTest.java)
             * queues
+              * [CircularQueueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/CircularQueueTest.java)
+              * [DequeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/DequeTest.java)
+              * [GenericArrayListQueueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/GenericArrayListQueueTest.java)
               * [LinkedQueueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/LinkedQueueTest.java)
               * [PriorityQueuesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/PriorityQueuesTest.java)
+              * [QueueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/QueueTest.java)
+            * stacks
+              * [LinkedListStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/LinkedListStackTest.java)
+              * [StackArrayListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/StackArrayListTest.java)
+              * [StackArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/StackArrayTest.java)
             * trees
               * [BinaryTreeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/BinaryTreeTest.java)
               * [BSTFromSortedArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/trees/BSTFromSortedArrayTest.java)
@@ -691,18 +717,27 @@
             * [BinaryExponentiationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/divideandconquer/BinaryExponentiationTest.java)
             * [StrassenMatrixMultiplicationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/divideandconquer/StrassenMatrixMultiplicationTest.java)
           * dynamicprogramming
+            * [BoardPathTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/BoardPathTest.java)
             * [CatalanNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/CatalanNumberTest.java)
             * [ClimbStairsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/ClimbStairsTest.java)
+            * [EditDistanceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/EditDistanceTest.java)
             * [EggDroppingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/EggDroppingTest.java)
             * [KnapsackMemoizationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackMemoizationTest.java)
             * [KnapsackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackTest.java)
             * [LevenshteinDistanceTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LevenshteinDistanceTests.java)
+            * [LongestAlternatingSubsequenceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestAlternatingSubsequenceTest.java)
             * [LongestIncreasingSubsequenceTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestIncreasingSubsequenceTests.java)
+            * [LongestPalindromicSubstringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstringTest.java)
+            * [LongestValidParenthesesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestValidParenthesesTest.java)
             * [MinimumPathSumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/MinimumPathSumTest.java)
             * [MinimumSumPartitionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/MinimumSumPartitionTest.java)
             * [OptimalJobSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/OptimalJobSchedulingTest.java)
+            * [PalindromicPartitioningTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/PalindromicPartitioningTest.java)
             * [PartitionProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/PartitionProblemTest.java)
+            * [RegexMatchingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/RegexMatchingTest.java)
+            * [ShortestCommonSupersequenceLengthTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/ShortestCommonSupersequenceLengthTest.java)
             * [SubsetCountTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SubsetCountTest.java)
+            * [SubsetSumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SubsetSumTest.java)
             * [SumOfSubsetTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SumOfSubsetTest.java)
             * [TribonacciTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/TribonacciTest.java)
             * [UniquePathsTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/UniquePathsTests.java)
@@ -735,9 +770,11 @@
             * [CollatzConjectureTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/CollatzConjectureTest.java)
             * [CombinationsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/CombinationsTest.java)
             * [CrossCorrelationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/CrossCorrelationTest.java)
+            * [DeterminantOfMatrixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/DeterminantOfMatrixTest.java)
             * [DigitalRootTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/DigitalRootTest.java)
             * [DistanceFormulaTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/DistanceFormulaTest.java)
             * [DudeneyNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/DudeneyNumberTest.java)
+            * [EulersFunctionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/EulersFunctionTest.java)
             * [FactorialRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FactorialRecursionTest.java)
             * [FactorialTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FactorialTest.java)
             * [FastInverseSqrtTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FastInverseSqrtTests.java)
@@ -746,6 +783,7 @@
             * [FibonacciLoopTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciLoopTest.java)
             * [FibonacciNumberCheckTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciNumberCheckTest.java)
             * [FibonacciNumberGoldenRationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciNumberGoldenRationTest.java)
+            * [FindKthNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FindKthNumberTest.java)
             * [FindMaxRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FindMaxRecursionTest.java)
             * [FindMaxTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FindMaxTest.java)
             * [FindMinRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FindMinRecursionTest.java)
@@ -753,6 +791,7 @@
             * [FloorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FloorTest.java)
             * [FrizzyNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FrizzyNumberTest.java)
             * [GaussianTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/GaussianTest.java)
+            * [GCDRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/GCDRecursionTest.java)
             * [GCDTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/GCDTest.java)
             * [GenericRootTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/GenericRootTest.java)
             * [HarshadNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/HarshadNumberTest.java)
@@ -773,6 +812,7 @@
             * [MinValueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/MinValueTest.java)
             * [MobiusFunctionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/MobiusFunctionTest.java)
             * [ModeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/ModeTest.java)
+            * [NonRepeatingElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/NonRepeatingElementTest.java)
             * [NthUglyNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/NthUglyNumberTest.java)
             * [NumberOfDigitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/NumberOfDigitsTest.java)
             * [PalindromeNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PalindromeNumberTest.java)
@@ -785,12 +825,14 @@
             * [PollardRhoTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PollardRhoTest.java)
             * [PowerOfTwoOrNotTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PowerOfTwoOrNotTest.java)
             * [PowerUsingRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PowerUsingRecursionTest.java)
+            * [PowTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PowTest.java)
             * [PrimeCheckTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PrimeCheckTest.java)
             * [PrimeFactorizationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PrimeFactorizationTest.java)
             * [PronicNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PronicNumberTest.java)
             * [PythagoreanTripleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/PythagoreanTripleTest.java)
             * [ReverseNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/ReverseNumberTest.java)
             * [SecondMinMaxTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SecondMinMaxTest.java)
+            * [SieveOfEratosthenesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SieveOfEratosthenesTest.java)
             * [SquareFreeIntegerTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SquareFreeIntegerTest.java)
             * [SquareRootwithBabylonianMethodTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SquareRootwithBabylonianMethodTest.java)
             * [SquareRootWithNewtonRaphsonTestMethod](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SquareRootWithNewtonRaphsonTestMethod.java)
@@ -825,8 +867,8 @@
             * [CountWordsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/CountWordsTest.java)
             * [CRC16Test](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/CRC16Test.java)
             * [CRCAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/CRCAlgorithmTest.java)
-            * [EulersFunctionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/EulersFunctionTest.java)
             * [FirstFitCPUTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/FirstFitCPUTest.java)
+            * [FloydTriangleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/FloydTriangleTest.java)
             * [KadaneAlogrithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/KadaneAlogrithmTest.java)
             * [LineSweepTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/LineSweepTest.java)
             * [LinkListSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/LinkListSortTest.java)
@@ -835,7 +877,10 @@
             * [NewManShanksPrimeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/NewManShanksPrimeTest.java)
             * [NextFitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/NextFitTest.java)
             * [PasswordGenTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/PasswordGenTest.java)
-            * [SieveOfEratosthenesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/SieveOfEratosthenesTest.java)
+            * [QueueUsingTwoStacksTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/QueueUsingTwoStacksTest.java)
+            * [RemoveDuplicateFromStringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/RemoveDuplicateFromStringTest.java)
+            * [ReturnSubsequenceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/ReturnSubsequenceTest.java)
+            * [ReverseStackUsingRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/ReverseStackUsingRecursionTest.java)
             * [StringMatchFiniteAutomataTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/StringMatchFiniteAutomataTest.java)
             * [TestPrintMatrixInSpiralOrder](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TestPrintMatrixInSpiralOrder.java)
             * [TwoPointersTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TwoPointersTest.java)
@@ -887,6 +932,7 @@
             * [OddEvenSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/OddEvenSortTest.java)
             * [PancakeSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/PancakeSortTest.java)
             * [PatienceSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/PatienceSortTest.java)
+            * [PigeonholeSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/PigeonholeSortTest.java)
             * [QuickSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/QuickSortTest.java)
             * [RadixSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/RadixSortTest.java)
             * [SelectionSortRecursiveTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SelectionSortRecursiveTest.java)
@@ -907,6 +953,14 @@
             * [WaveSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/WaveSortTest.java)
             * [WiggleSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/WiggleSortTest.java)
           * stacks
+            * [BalancedBracketsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/BalancedBracketsTest.java)
+            * [DecimalToAnyUsingStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/DecimalToAnyUsingStackTest.java)
+            * [DuplicateBracketsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/DuplicateBracketsTest.java)
+            * [InfixToPostfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/InfixToPostfixTest.java)
+            * [LargestRectangleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/LargestRectangleTest.java)
+            * [NextGreaterElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/NextGreaterElementTest.java)
+            * [NextSmallerElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/NextSmallerElementTest.java)
+            * [PostfixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PostfixToInfixTest.java)
             * [StackPostfixNotationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/StackPostfixNotationTest.java)
           * strings
             * [AhoCorasickTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/AhoCorasickTest.java)
@@ -919,11 +973,13 @@
             * [HorspoolSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/HorspoolSearchTest.java)
             * [IsomorphicTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/IsomorphicTest.java)
             * [LetterCombinationsOfPhoneNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/LetterCombinationsOfPhoneNumberTest.java)
-            * [LongestNonRepeativeSubstringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/LongestNonRepeativeSubstringTest.java)
+            * [LongestNonRepetitiveSubstringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/LongestNonRepetitiveSubstringTest.java)
+            * [LongestPalindromicSubstringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/LongestPalindromicSubstringTest.java)
             * [LowerTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/LowerTest.java)
             * [MyAtoiTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/MyAtoiTest.java)
             * [PalindromeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/PalindromeTest.java)
             * [PangramTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/PangramTest.java)
+            * [PermuteStringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/PermuteStringTest.java)
             * [ReverseStringRecursiveTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/ReverseStringRecursiveTest.java)
             * [ReverseStringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/ReverseStringTest.java)
             * [ReverseWordsInStringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/ReverseWordsInStringTest.java)

From 99e6f9744b02e83236cb305e08845ffde620550a Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sat, 31 Aug 2024 13:36:08 +0700
Subject: [PATCH 23/27] chore: format code

---
 .../datastructures/trees/SplayTree.java       | 48 ++++++++++++-------
 1 file changed, 31 insertions(+), 17 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index f761e665c740..ae120739d07b 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -5,18 +5,23 @@
 
 /**
  * Implementation of a Splay Tree data structure.
- * 
- * A splay tree is a self-adjusting binary search tree with the additional property
+ *
+ * A splay tree is a self-adjusting binary search tree with the additional
+ * property
  * that recently accessed elements are quick to access again. It performs basic
- * operations such as insertion, deletion, and searching in O(log n) amortized time,
+ * operations such as insertion, deletion, and searching in O(log n) amortized
+ * time,
  * where n is the number of elements in the tree.
- * 
- * The key feature of splay trees is the splay operation, which moves a node closer
+ *
+ * The key feature of splay trees is the splay operation, which moves a node
+ * closer
  * to the root of the tree when it is accessed. This operation helps to maintain
- * good balance and improves the overall performance of the tree. After performing
+ * good balance and improves the overall performance of the tree. After
+ * performing
  * a splay operation, the accessed node becomes the new root of the tree.
- * 
- * Splay trees have applications in various areas, including caching, network routing,
+ *
+ * Splay trees have applications in various areas, including caching, network
+ * routing,
  * and dynamic optimality analysis.
  */
 public class SplayTree {
@@ -102,8 +107,10 @@ public List<Integer> traverse(TreeTraversal traversal) {
      * Zig operation.
      *
      * <p>
-     * The zig operation is used to perform a single rotation on a node to move it closer to
-     * the root of the tree. It is typically applied when the node is a left child of its parent
+     * The zig operation is used to perform a single rotation on a node to move it
+     * closer to
+     * the root of the tree. It is typically applied when the node is a left child
+     * of its parent
      * and needs to be rotated to the right.
      * </p>
      *
@@ -121,8 +128,10 @@ private Node rotateRight(Node x) {
      * Zag operation.
      *
      * <p>
-     * The zag operation is used to perform a single rotation on a node to move it closer to
-     * the root of the tree. It is typically applied when the node is a right child of its parent
+     * The zag operation is used to perform a single rotation on a node to move it
+     * closer to
+     * the root of the tree. It is typically applied when the node is a right child
+     * of its parent
      * and needs to be rotated to the left.
      * </p>
      *
@@ -140,9 +149,12 @@ private Node rotateLeft(Node x) {
      * Splay operation.
      *
      * <p>
-     * The splay operation is the core operation of a splay tree. It moves a specified node
-     * closer to the root of the tree by performing a series of rotations. The goal of the splay
-     * operation is to improve the access time for frequently accessed nodes by bringing them
+     * The splay operation is the core operation of a splay tree. It moves a
+     * specified node
+     * closer to the root of the tree by performing a series of rotations. The goal
+     * of the splay
+     * operation is to improve the access time for frequently accessed nodes by
+     * bringing them
      * closer to the root.
      * </p>
      *
@@ -150,13 +162,15 @@ private Node rotateLeft(Node x) {
      * The splay operation consists of three main cases:
      * <ul>
      * <li>Zig-Zig case: Perform two consecutive rotations.</li>
-     * <li>Zig-Zag case: Perform two consecutive rotations in opposite directions.</li>
+     * <li>Zig-Zag case: Perform two consecutive rotations in opposite
+     * directions.</li>
      * <li>Zag-Zag case: Perform two consecutive rotations.</li>
      * </ul>
      * </p>
      *
      * <p>
-     * After performing the splay operation, the accessed node becomes the new root of the tree.
+     * After performing the splay operation, the accessed node becomes the new root
+     * of the tree.
      * </p>
      *
      * @param root The root of the subtree to splay.

From 1402ab97ea9efbd641a8401fc0e067b3d1c421f5 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sat, 31 Aug 2024 13:53:20 +0700
Subject: [PATCH 24/27] chore: remove redundant `final`

---
 .../com/thealgorithms/datastructures/trees/SplayTree.java     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index ae120739d07b..e1e37c23a248 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -177,7 +177,7 @@ private Node rotateLeft(Node x) {
      * @param key  The key to splay around.
      * @return The new root of the splayed subtree.
      */
-    private final Node splay(Node root, int key) {
+    private Node splay(Node root, int key) {
         if (root == null || root.key == key) {
             return root;
         }
@@ -215,7 +215,7 @@ private final Node splay(Node root, int key) {
         }
     }
 
-    private final Node insertRec(Node root, int key) {
+    private Node insertRec(Node root, int key) {
         if (root == null) {
             return new Node(key);
         }

From a91704709c5ca59abd5e70e735271dc5e44435db Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 1 Sep 2024 20:04:28 +0700
Subject: [PATCH 25/27] ref: improve splay tree - Add `final` to the `key` -
 Add `serialVersionUID` field to the exception classes

---
 .../datastructures/trees/SplayTree.java       | 35 ++++++++++++++-----
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index e1e37c23a248..66894b509d0c 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -45,7 +45,7 @@ public boolean isEmpty() {
      *
      * @param key The key to insert.
      */
-    public final void insert(int key) {
+    public void insert(final int key) {
         root = insertRec(root, key);
         root = splay(root, key);
     }
@@ -67,29 +67,42 @@ public boolean search(int key) {
      * @param key The key to delete.
      * @throws IllegalArgumentException If the tree is empty.
      */
-    public final void delete(int key) {
+    public void delete(final int key) {
         if (isEmpty()) {
             throw new EmptyTreeException("Cannot delete from an empty tree");
         }
 
-        // Splay the tree with the key to be deleted
         root = splay(root, key);
 
-        // If the key is not found at the root, return without deleting
         if (root.key != key) {
             return;
         }
 
-        // Handle deletion
         if (root.left == null) {
             root = root.right;
         } else {
-            // Splay to bring the largest key in left subtree to root
             Node temp = root;
-            root = splay(root.left, key);
+            root = splay(root.left, findMax(root.left).key);
             root.right = temp.right;
         }
     }
+    /**
+     * Finds the node with the maximum key in a given subtree.
+     *
+     * <p>
+     * This method traverses the right children of the subtree until it finds the
+     * rightmost node, which contains the maximum key.
+     * </p>
+     *
+     * @param root The root node of the subtree.
+     * @return The node with the maximum key in the subtree.
+     */
+    private Node findMax(Node root) {
+        while (root.right != null) {
+            root = root.right;
+        }
+        return root;
+    }
 
     /**
      * Perform a traversal of the SplayTree.
@@ -177,7 +190,7 @@ private Node rotateLeft(Node x) {
      * @param key  The key to splay around.
      * @return The new root of the splayed subtree.
      */
-    private Node splay(Node root, int key) {
+    private Node splay(Node root, final int key) {
         if (root == null || root.key == key) {
             return root;
         }
@@ -215,7 +228,7 @@ private Node splay(Node root, int key) {
         }
     }
 
-    private Node insertRec(Node root, int key) {
+    private Node insertRec(Node root, final int key) {
         if (root == null) {
             return new Node(key);
         }
@@ -232,12 +245,16 @@ private Node insertRec(Node root, int key) {
     }
 
     public static class EmptyTreeException extends RuntimeException {
+        private static final long serialVersionUID = 1L;
+
         public EmptyTreeException(String message) {
             super(message);
         }
     }
 
     public static class DuplicateKeyException extends RuntimeException {
+        private static final long serialVersionUID = 1L;
+
         public DuplicateKeyException(String message) {
             super(message);
         }

From 5431d3ef8b7bd8d80490fd3ce0849089fdeb96f7 Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 1 Sep 2024 20:11:41 +0700
Subject: [PATCH 26/27] chore: reorganize code structure

---
 .../datastructures/trees/SplayTree.java       | 25 ++++++++++---------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
index 66894b509d0c..2668b609aedc 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/SplayTree.java
@@ -86,6 +86,19 @@ public void delete(final int key) {
             root.right = temp.right;
         }
     }
+
+    /**
+     * Perform a traversal of the SplayTree.
+     *
+     * @param traversal The type of traversal method.
+     * @return A list containing the keys in the specified traversal order.
+     */
+    public List<Integer> traverse(TreeTraversal traversal) {
+        List<Integer> result = new LinkedList<>();
+        traversal.traverse(root, result);
+        return result;
+    }
+
     /**
      * Finds the node with the maximum key in a given subtree.
      *
@@ -104,18 +117,6 @@ private Node findMax(Node root) {
         return root;
     }
 
-    /**
-     * Perform a traversal of the SplayTree.
-     *
-     * @param traversal The type of traversal method.
-     * @return A list containing the keys in the specified traversal order.
-     */
-    public List<Integer> traverse(TreeTraversal traversal) {
-        List<Integer> result = new LinkedList<>();
-        traversal.traverse(root, result);
-        return result;
-    }
-
     /**
      * Zig operation.
      *

From 155e54bc9c8705cbae142bd921e2f56fbcfc997a Mon Sep 17 00:00:00 2001
From: Truong Nhan Nguyen <nhantruongnguyen123@gmail.com>
Date: Sun, 1 Sep 2024 20:15:51 +0700
Subject: [PATCH 27/27] chore: remove redundant test

---
 .../datastructures/trees/SplayTreeTest.java        | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
index ee87206b585d..d520be94e7f3 100644
--- a/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/trees/SplayTreeTest.java
@@ -8,7 +8,6 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Stream;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -111,17 +110,4 @@ private SplayTree createComplexTree() {
 
         return tree;
     }
-
-    @Test
-    public void testZigZagCaseWithNullChild() {
-        SplayTree tree = new SplayTree();
-        tree.insert(30);
-        tree.insert(10);
-        tree.insert(20);
-        tree.insert(15);
-
-        assertTrue(tree.search(15));
-
-        assertEquals(Arrays.asList(10, 15, 20, 30), tree.traverse(SplayTree.IN_ORDER));
-    }
 }