ref: improve splay tree

Author: sozelfist

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();
 }

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