Add Splay Tree implementation (#13760) [hacktoberfest]

This PR adds a Splay Tree (Self Adjusting BST) implementation in Python under the `data_structures/binary_tree/` directory.

## Details:
- Implements the Splay Tree data structure with all core operations: insertion, search, splay rotation, and inorder traversal.
- Includes class-based design (`Node`, `SplayTree`) and follows Python community style.
- Provides an example usage and test in the `__main__` block.

## Why Splay Tree?
A Splay Tree is a self-adjusting binary search tree that provides fast access to recently used elements by moving them closer to the root through 'splaying' operations. Frequently accessed nodes move towards the top, which is useful for caching and memory management systems.

## Issue Reference
This solves [Issue #13760](#13760).

## Hacktoberfest
Marking this contribution for Hacktoberfest 2025.  
**For Maintainers:** Please add the `hacktoberfest-accepted` label to count this PR towards Hacktoberfest.

## Checklist
- [x] Follows contribution guidelines
- [x] Code is documented with docstrings and inline comments
- [x] Includes an example/test case
- [x] New file in correct directory

---

Feel free to use or modify the text above for your commit and pull request! If you want it in Hinglish or need a quick summary, let me know.

Author: gunjan-ghangare

data_structures/binary_tree/splay_tree.py

@@ -12,13 +12,18 @@ def __init__(self, key):
         self.parent = None
         self.key = key
 
+    def __repr__(self):
+        return f"Node({self.key})"
+
 
 class SplayTree:
     def __init__(self):
         self.root = None
 
     def _right_rotate(self, x):
         y = x.left
+        if not y:
+            return
         x.left = y.right
         if y.right:
             y.right.parent = x
@@ -34,6 +39,8 @@ def _right_rotate(self, x):
 
     def _left_rotate(self, x):
         y = x.right
+        if not y:
+            return
         x.right = y.left
         if y.left:
             y.left.parent = x
@@ -48,25 +55,30 @@ def _left_rotate(self, x):
         x.parent = y
 
     def _splay(self, x):
-        while x.parent:
-            if not x.parent.parent:
-                if x.parent.left == x:
-                    self._right_rotate(x.parent)
+        while x and x.parent:
+            p = x.parent
+            g = p.parent
+            # Zig step (p is root)
+            if not g:
+                if p.left == x:
+                    self._right_rotate(p)
                 else:
-                    self._left_rotate(x.parent)
+                    self._left_rotate(p)
             else:
-                if x.parent.left == x and x.parent.parent.left == x.parent:
-                    self._right_rotate(x.parent.parent)
-                    self._right_rotate(x.parent)
-                elif x.parent.right == x and x.parent.parent.right == x.parent:
-                    self._left_rotate(x.parent.parent)
-                    self._left_rotate(x.parent)
-                elif x.parent.left == x and x.parent.parent.right == x.parent:
-                    self._right_rotate(x.parent)
-                    self._left_rotate(x.parent)
-                else:
-                    self._left_rotate(x.parent)
-                    self._right_rotate(x.parent)
+                # Zig-Zig
+                if p.left == x and g.left == p:
+                    self._right_rotate(g)
+                    self._right_rotate(p)
+                elif p.right == x and g.right == p:
+                    self._left_rotate(g)
+                    self._left_rotate(p)
+                # Zig-Zag
+                elif p.left == x and g.right == p:
+                    self._right_rotate(p)
+                    self._left_rotate(g)
+                else:  # p.right == x and g.left == p
+                    self._left_rotate(p)
+                    self._right_rotate(g)
 
     def insert(self, key):
         z = self.root
@@ -89,26 +101,29 @@ def insert(self, key):
 
     def search(self, key):
         z = self.root
+        last = None
         while z:
+            last = z
             if key == z.key:
                 self._splay(z)
                 return z
             elif key < z.key:
-                if not z.left:
-                    self._splay(z)
-                    return None
                 z = z.left
             else:
-                if not z.right:
-                    self._splay(z)
-                    return None
                 z = z.right
+        # splay the last accessed node (closest) if present
+        if last:
+            self._splay(last)
         return None
 
     def inorder(self, node=None, result=None):
         if result is None:
             result = []
-        node = node or self.root
+        # if node is explicitly passed as None and tree is empty, return empty result
+        if node is None:
+            node = self.root
+        if node is None:
+            return result
         if node.left:
             self.inorder(node.left, result)
         result.append(node.key)
@@ -120,6 +135,9 @@ def inorder(self, node=None, result=None):
 # Example Usage / Test
 if __name__ == "__main__":
     tree = SplayTree()
+    # empty tree -> inorder should return []
+    print(tree.inorder())  # []
+
     for key in [10, 20, 30, 40, 50, 25]:
         tree.insert(key)
     print(tree.inorder())  # Output should be the inorder traversal of tree