Splaying Trees

Blooverh · Blooverh · commit da4ce6bdece9 · 2023-08-14T21:39:38.000-05:00
diff --git a/BinarySearchTrees/SplayTrees.py b/BinarySearchTrees/SplayTrees.py
@@ -0,0 +1,34 @@
+import TreeMap
+
+class SplayTreeMap(TreeMap):
+    """Sorted map implementation using a splay tree"""
+
+    def _splay(self, p):
+
+        while p != self.root():
+            parent = self.parent(p) # y is parent of x 
+            grand = self.parent(parent) # z is parent of y
+
+            if grand is None:
+                # if there is no z (grand father)
+                # zig-zag case
+                self._rotate(p) # from treeMap class 
+            elif (parent == self.left(grand)) == (p == self.left(parent)):
+                # zig-zig case 
+                self._rotate(parent) # move parent up
+                self._rotate(p) # move child p (x) up to the root
+            else:
+                #zig-zag case 
+                self._rotate(p) #  move p up
+                self._rotate(p) #move p up again
+
+    ##### OVERRIDE BALANCING HOOKS #######
+    def _rebalance_insert(self,p):
+        self._splay(p)
+    
+    def _rebalance_delete(self, p):
+        if p is not None:
+            self._splay(p)
+
+    def _rebalance_access(self, p):
+        self._splay(p)
diff --git a/BinarySearchTrees/TreeMap.py b/BinarySearchTrees/TreeMap.py
@@ -212,48 +212,48 @@ def __delitem__(self, k):
 
 ######### Search Tree Balacing Algorithms for (AVL, Splay Tree, RedBlack Trees) not used by this class, but implemented here for inheritance ######
 
-def _relink(self, parent, child, make_left_child):
-    """Relink aprent node with child node (we allow child to be None)"""
+    def _relink(self, parent, child, make_left_child):
+        """Relink aprent node with child node (we allow child to be None)"""
 
-    if make_left_child:
-        parent._left = child #make it a left child
-    else:
-        parent._right = child # make it a right child
-
-    if child is not None:
-        child._parent = parent # make child point to parent 
+        if make_left_child:
+            parent._left = child #make it a left child
+        else:
+            parent._right = child # make it a right child
 
-def _rotate(self, p):
-    """rotate position p above its parent"""
-    x = p._node
-    y = x._parent #assume this exists
-    z= y._parent # grand parent 
+        if child is not None:
+            child._parent = parent # make child point to parent 
 
-    if z is None:
-        self._root = x #x becomes root if grand parent z is None 
-        x._parent = None
-    else:
-        self._relink(z,x, y == z._left) # x becomes a direct child of z
-    
-    # now rotate x and y, including transfer of middle subtree
-    if x == y._left:
-        self._relink(y, x._right, True) # x._right becomes left child of y 
-        self._relink(x, y, False)
-    else:
-        self._relink(y, x._left, False) # x._left becomes right child of y
-        self._relink(x , y, True) # Y becomes left child of x
+    def _rotate(self, p):
+        """rotate position p above its parent"""
+        x = p._node
+        y = x._parent #assume this exists
+        z= y._parent # grand parent 
 
-def _restructure(self, x):
-    """Perform Trinode Restructuring of Position x with parent/grandparent"""
+        if z is None:
+            self._root = x #x becomes root if grand parent z is None (does not exist)
+            x._parent = None
+        else:
+            self._relink(z,x, y == z._left) # x becomes a direct child of z
+        
+        # now rotate x and y, including transfer of middle subtree
+        if x == y._left:
+            self._relink(y, x._right, True) # x._right becomes left child of y 
+            self._relink(x, y, False)
+        else:
+            self._relink(y, x._left, False) # x._left becomes right child of y
+            self._relink(x , y, True) # Y becomes left child of x
+            
+    def _restructure(self, x):
+        """Perform Trinode Restructuring of Position x with parent/grandparent"""
 
-    y= self.parent(x)
-    z = self.parent(y)
+        y= self.parent(x)
+        z = self.parent(y)
 
-    if (x == self.right(y)) == (y== self.right(z)): #matching alignments
-        self._rotate(y) #single rotation
-        return y # y is the new subtree root
-    else:
-        self._rotate(x) #double rotation
-        self._rotate(x)
+        if (x == self.right(y)) == (y== self.right(z)): #matching alignments
+            self._rotate(y) #single rotation
+            return y # y is the new subtree root
+        else:
+            self._rotate(x) #double rotation
+            self._rotate(x)
 
-        return x
+            return x
