ref: refactor SplayTree implementation

sozelfist · sozelfist · commit 3e77e927493a · 2024-05-31T08:55:31.000+07:00
- Implement 3 traversal class of the `TreeTraversal` interface
- Addjust tests to better cover code.
diff --git 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
@@ -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,55 +66,42 @@ 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() {
         return Stream.of(1, 5, 10);
     }
 
     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;
     }
 }
