Fixed all lint issues and finalized Splay Tree implementation

Author: yeshuawm999

data_structures/binary_tree/splay_tree.py

@@ -9,30 +9,6 @@
 Author: yeshuawm999
 """
 
-<<<<<<< HEAD
-
-# class node
-class Node:
-    """A node in the Splay Tree."""
-
-    def __init__(self, key, parent=None, left=None, right=None):
-        self.key = key  # The value stored in the node
-        self.parent = parent  # Pointer to the parent node
-        self.left = left  # Pointer to the left child
-        self.right = right  # Pointer to the right child
-
-
-# Spary Tree class
-class SplayTree:
-    """A self-adjusting Binary Search Tree."""
-
-    def __init__(self):
-        self.root = None  # The root of the tree
-
-    # --- Basic Rotation Operations ---
-
-    def _rotate_left(self, x):
-=======
 from __future__ import annotations
 from typing import Optional
 
@@ -43,9 +19,9 @@ class Node:
     def __init__(
         self,
         key: int,
-        parent: Optional[Node] = None,
-        left: Optional[Node] = None,
-        right: Optional[Node] = None,
+        parent: Optional["Node"] = None,
+        left: Optional["Node"] = None,
+        right: Optional["Node"] = None,
     ) -> None:
         self.key = key
         self.parent = parent
@@ -62,117 +38,61 @@ def __init__(self) -> None:
     # --- Basic Rotation Operations ---
 
     def _rotate_left(self, x: Node) -> None:
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
-        """Perform a left rotation around node x (moving x down and right)."""
+        """Perform a left rotation around node x."""
         y = x.right
         if not y:
             return
         x.right = y.left
         if y.left:
             y.left.parent = x
 
-<<<<<<< HEAD
-        # 2. Update y's parent to be x's parent
-        y.parent = x.parent
-        if not x.parent:
-            self.root = y  # y becomes the new root
-=======
         y.parent = x.parent
         if not x.parent:
             self.root = y
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
         elif x == x.parent.left:
             x.parent.left = y
         else:
             x.parent.right = y
 
-<<<<<<< HEAD
-        # 3. Update y's left child to be x
-=======
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
         y.left = x
         x.parent = y
 
     def _rotate_right(self, x: Node) -> None:
-        """Perform a right rotation around node x (moving x down and left)."""
+        """Perform a right rotation around node x."""
         y = x.left
         if not y:
             return
         x.left = y.right
         if y.right:
             y.right.parent = x
 
-<<<<<<< HEAD
-        # 2. Update y's parent to be x's parent
-        y.parent = x.parent
-        if not x.parent:
-            self.root = y  # y becomes the new new root
-=======
         y.parent = x.parent
         if not x.parent:
             self.root = y
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
         elif x == x.parent.right:
             x.parent.right = y
         else:
             x.parent.left = y
 
-<<<<<<< HEAD
-        # 3. Update y's right child to be x
-=======
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
         y.right = x
         x.parent = y
 
     # --- Core Splay Operation ---
 
-<<<<<<< HEAD
-    def _splay(self, x):
-=======
     def _splay(self, x: Node) -> None:
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
         """Moves node x to the root of the tree using a sequence of rotations."""
         while x.parent:
             parent = x.parent
             grandparent = parent.parent
 
             if not grandparent:
                 # Zig Case (x is a child of the root)
-                # One single rotation (Right if left child, Left if right child)
+                # One single rotation:
+                # Right if x is a left child, Left if x is a right child
                 if x == parent.left:
                     self._rotate_right(parent)
                 else:
                     self._rotate_left(parent)
-<<<<<<< HEAD
-
-            else:
-                # Two rotations are performed: Zig-Zig or Zig-Zag
-
-                # Case 1: Zig-Zig (x, parent, and grandparent are all on one side)
-                if x == parent.left and parent == grandparent.left:
-                    # x and parent are both left children (Left-Left)
-                    self._rotate_right(grandparent)  # Rotate grandparent down
-                    self._rotate_right(parent)  # Rotate parent down
-                elif x == parent.right and parent == grandparent.right:
-                    # x and parent are both right children (Right-Right)
-                    self._rotate_left(grandparent)  # Rotate grandparent down
-                    self._rotate_left(parent)  # Rotate parent down
-
-                # Case 2: Zig-Zag (x is on one side, parent is on the other)
-                elif x == parent.left and parent == grandparent.right:
-                    # x is left child, parent is right child
-                    self._rotate_right(parent)  # Rotate parent first
-                    self._rotate_left(grandparent)  # Rotate grandparent next
-                else:  # x == parent.right and parent == grandparent.left
-                    # x is right child, parent is left child
-                    self._rotate_left(parent)  # Rotate parent first
-                    self._rotate_right(grandparent)  # Rotate grandparent next
-
-    # --- Example Search Method (Uses splay) ---
-
-    def search(self, key):
-        """Searches for a key. If found, splays it to the root."""
-=======
 
             # Two rotations are performed: Zig-Zig or Zig-Zag
             elif x == parent.left and parent == grandparent.left:
@@ -187,7 +107,7 @@ def search(self, key):
                 # Case 2: Zig-Zag (x is left child, parent is right child)
                 self._rotate_right(parent)
                 self._rotate_left(grandparent)
-            else:
+            elif x == parent.right and parent == grandparent.left:
                 # Case 2: Zig-Zag (x is right child, parent is left child)
                 self._rotate_left(parent)
                 self._rotate_right(grandparent)
@@ -196,7 +116,6 @@ def search(self, key):
 
     def search(self, key: int) -> bool:
         """Search for a key. If found, splay it to the root."""
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
         current = self.root
         found_node = None
         while current:
@@ -209,22 +128,15 @@ def search(self, key: int) -> bool:
                 current = current.right
 
         if found_node:
-<<<<<<< HEAD
-            self._splay(found_node)  # Node is brought to the root
-=======
             self._splay(found_node)
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
             return True
         return False
 
 
-<<<<<<< HEAD
-=======
-# --- Example Usage (for TheAlgorithms CI testing) ---
->>>>>>> 5d5b0f04 (Fixed lint issues, added type hints, and cleaned Splay Tree implementation)
+# --- Example Usage ---
 if __name__ == "__main__":
     """
-    Example:
+    Example run:
     >>> tree = SplayTree()
     >>> tree.root = Node(10)
     >>> tree.root.left = Node(5, parent=tree.root)
@@ -234,6 +146,7 @@ def search(self, key: int) -> bool:
     >>> print("Found:", found)
     >>> print("After splay, new root:", tree.root.key)
     """
+
     tree = SplayTree()
     tree.root = Node(10)
     tree.root.left = Node(5, parent=tree.root)