add splay tree

Author: rafaelalmeida2909

AVL Tree.py

@@ -37,8 +37,9 @@ def updateHeights(self, node):
         while True:
             if node is None:
                 break
-            node.height = max(self.heightNode(node.left),
-                              self.heightNode(node.right)) + 1
+            node.height = (
+                max(self.heightNode(node.left), self.heightNode(node.right)) + 1
+            )
             node = node.parent
 
     def balanceTree(self, node):
@@ -83,8 +84,9 @@ def returnNode(self, current):
                 node2.left.parent = node1
             node2.left = current.left
             node1.parent = current.left
-            node1.height = max(self.heightNode(node1.left),
-                               self.heightNode(node1.right)) + 1
+            node1.height = (
+                max(self.heightNode(node1.left), self.heightNode(node1.right)) + 1
+            )
         node2.right = current.right
         if current.right != None:
             current.right.parent = node2
@@ -100,8 +102,7 @@ def rrRotation(self, root):
         """Right rotation function"""
         node = self.copy(root.left)
         root.left = node.right
-        root.height = max(self.heightNode(root.left),
-                          self.heightNode(root.right)) + 1
+        root.height = max(self.heightNode(root.left), self.heightNode(root.right)) + 1
         node.right = self.copy(root)
         node.height = max(self.heightNode(node.left), root.height) + 1
         root.data = node.data
@@ -119,8 +120,7 @@ def llRotation(self, root):
         """Left rotation function"""
         node = self.copy(root.right)
         root.right = node.left
-        root.height = max(self.heightNode(root.left),
-                          self.heightNode(root.right)) + 1
+        root.height = max(self.heightNode(root.left), self.heightNode(root.right)) + 1
         node.left = self.copy(root)
         node.height = max(self.heightNode(node.right), root.height) + 1
         root.data = node.data
@@ -306,7 +306,7 @@ def height(self, node):
         else:
             left_height = self.height(node.left)
             right_height = self.height(node.right)
-            if (left_height > right_height):
+            if left_height > right_height:
                 return left_height + 1
             else:
                 return right_height + 1
@@ -336,45 +336,44 @@ def printTree(self, node=None):
     def _printTree(self, node):
         """Auxiliary function to print the Avl Tree"""
         if node.right is None and node.left is None:  # No child
-            line = '%s' % node.data
+            line = "%s" % node.data
             width = len(line)
             height = 1
             middle = width // 2
             return [line], width, height, middle
 
         if node.right is None:  # Only left child
             lines, n, p, x = self._printTree(node.left)
-            s = '%s' % node.data
+            s = "%s" % node.data
             u = len(s)
-            first_line = (x + 1) * ' ' + (n - x - 1) * '_' + s
-            second_line = x * ' ' + '/' + (n - x - 1 + u) * ' '
-            shifted_lines = [line + u * ' ' for line in lines]
+            first_line = (x + 1) * " " + (n - x - 1) * "_" + s
+            second_line = x * " " + "/" + (n - x - 1 + u) * " "
+            shifted_lines = [line + u * " " for line in lines]
             return [first_line, second_line] + shifted_lines, n + u, p + 2, n + u // 2
 
         if node.left is None:  # Only right child
             lines, n, p, x = self._printTree(node.right)
-            s = '%s' % node.data
+            s = "%s" % node.data
             u = len(s)
-            first_line = s + x * '_' + (n - x) * ' '
-            second_line = (u + x) * ' ' + '\\' + (n - x - 1) * ' '
-            shifted_lines = [u * ' ' + line for line in lines]
+            first_line = s + x * "_" + (n - x) * " "
+            second_line = (u + x) * " " + "\\" + (n - x - 1) * " "
+            shifted_lines = [u * " " + line for line in lines]
             return [first_line, second_line] + shifted_lines, n + u, p + 2, u // 2
 
         left, n, p, x = self._printTree(node.left)  # Two children
         right, m, q, y = self._printTree(node.right)
-        s = '%s' % node.data
+        s = "%s" % node.data
         u = len(s)
-        first_line = (x + 1) * ' ' + (n - x - 1) * \
-            '_' + s + y * '_' + (m - y) * ' '
-        second_line = x * ' ' + '/' + \
-            (n - x - 1 + u + y) * ' ' + '\\' + (m - y - 1) * ' '
+        first_line = (x + 1) * " " + (n - x - 1) * "_" + s + y * "_" + (m - y) * " "
+        second_line = (
+            x * " " + "/" + (n - x - 1 + u + y) * " " + "\\" + (m - y - 1) * " "
+        )
         if p < q:
-            left += [n * ' '] * (q - p)
+            left += [n * " "] * (q - p)
         elif q < p:
-            right += [m * ' '] * (p - q)
+            right += [m * " "] * (p - q)
         zipped_lines = zip(left, right)
-        lines = [first_line, second_line] + \
-            [a + u * ' ' + b for a, b in zipped_lines]
+        lines = [first_line, second_line] + [a + u * " " + b for a, b in zipped_lines]
         return lines, n + m + u, max(p, q) + 2, n + u // 2
 
     def printHeights(self):
@@ -387,8 +386,7 @@ def _printHeights(self, cur_node):
         """Auxiliary function to print the height of nodes"""
         if cur_node != None:
             self._printHeights(cur_node.left)
-            print(f'{cur_node.data},'.center(5) +
-                  f' {str(cur_node.height).center(6)}')
+            print(f"{cur_node.data},".center(5) + f" {str(cur_node.height).center(6)}")
             self._printHeights(cur_node.right)
 
     def printParents(self):
@@ -402,9 +400,10 @@ def _printParents(self, cur_node):
         if cur_node != None:
             self._printParents(cur_node.left)
             if cur_node.parent != None:
-                print(f'{cur_node.data},'.center(5) +
-                  f' {str(cur_node.parent.data).center(6)}')
+                print(
+                    f"{cur_node.data},".center(5)
+                    + f" {str(cur_node.parent.data).center(6)}"
+                )
             else:
-                print(f'{cur_node.data},'.center(5) +
-                  f' {str(None).center(6)}')
+                print(f"{cur_node.data},".center(5) + f" {str(None).center(6)}")
             self._printParents(cur_node.right)

Binary Tree.py

@@ -154,7 +154,7 @@ def height(self, node):
         else:
             left_height = self.height(node.left)
             right_height = self.height(node.right)
-            if (left_height > right_height):
+            if left_height > right_height:
                 return left_height + 1
             else:
                 return right_height + 1
@@ -172,55 +172,54 @@ def empty(self):
         if self._root is None:
             return True
         return False
-    
+
     def printTree(self, node=None):
-        """Prints the Avl Tree"""
+        """Prints the Tree"""
         if node is None:
             node = self._root
         lines, *_ = self._printTree(node)
         for line in lines:
             print(line)
 
     def _printTree(self, node):
-        """Auxiliary function to print the Avl Tree"""
+        """Auxiliary function to print the Tree"""
         if node.right is None and node.left is None:  # No child
-            line = '%s' % node.data
+            line = "%s" % node.data
             width = len(line)
             height = 1
             middle = width // 2
             return [line], width, height, middle
 
         if node.right is None:  # Only left child
             lines, n, p, x = self._printTree(node.left)
-            s = '%s' % node.data
+            s = "%s" % node.data
             u = len(s)
-            first_line = (x + 1) * ' ' + (n - x - 1) * '_' + s
-            second_line = x * ' ' + '/' + (n - x - 1 + u) * ' '
-            shifted_lines = [line + u * ' ' for line in lines]
+            first_line = (x + 1) * " " + (n - x - 1) * "_" + s
+            second_line = x * " " + "/" + (n - x - 1 + u) * " "
+            shifted_lines = [line + u * " " for line in lines]
             return [first_line, second_line] + shifted_lines, n + u, p + 2, n + u // 2
 
         if node.left is None:  # Only right child
             lines, n, p, x = self._printTree(node.right)
-            s = '%s' % node.data
+            s = "%s" % node.data
             u = len(s)
-            first_line = s + x * '_' + (n - x) * ' '
-            second_line = (u + x) * ' ' + '\\' + (n - x - 1) * ' '
-            shifted_lines = [u * ' ' + line for line in lines]
+            first_line = s + x * "_" + (n - x) * " "
+            second_line = (u + x) * " " + "\\" + (n - x - 1) * " "
+            shifted_lines = [u * " " + line for line in lines]
             return [first_line, second_line] + shifted_lines, n + u, p + 2, u // 2
 
         left, n, p, x = self._printTree(node.left)  # Two children
         right, m, q, y = self._printTree(node.right)
-        s = '%s' % node.data
+        s = "%s" % node.data
         u = len(s)
-        first_line = (x + 1) * ' ' + (n - x - 1) * \
-            '_' + s + y * '_' + (m - y) * ' '
-        second_line = x * ' ' + '/' + \
-            (n - x - 1 + u + y) * ' ' + '\\' + (m - y - 1) * ' '
+        first_line = (x + 1) * " " + (n - x - 1) * "_" + s + y * "_" + (m - y) * " "
+        second_line = (
+            x * " " + "/" + (n - x - 1 + u + y) * " " + "\\" + (m - y - 1) * " "
+        )
         if p < q:
-            left += [n * ' '] * (q - p)
+            left += [n * " "] * (q - p)
         elif q < p:
-            right += [m * ' '] * (p - q)
+            right += [m * " "] * (p - q)
         zipped_lines = zip(left, right)
-        lines = [first_line, second_line] + \
-            [a + u * ' ' + b for a, b in zipped_lines]
+        lines = [first_line, second_line] + [a + u * " " + b for a, b in zipped_lines]
         return lines, n + m + u, max(p, q) + 2, n + u // 2

Circular Queue.py

@@ -53,7 +53,7 @@ def last(self):
         """Returns the last element from queue"""
         if self._size == 0:
             raise Exception("Empty queue")
-        return self._queue[self._back-1]
+        return self._queue[self._back - 1]
 
     def empty(self):
         """Verifys if the queue is empty"""

Doubly Linked List.py

@@ -78,7 +78,7 @@ def insert(self, index, elem):
             self._size += 1
         elif index > 0:
             node_next = self.getItemByIndex(index)
-            node_prev = self.getItemByIndex(index-1)
+            node_prev = self.getItemByIndex(index - 1)
             node.next = node_next
             node.prev = node_prev
             node_next.prev = node
@@ -110,7 +110,7 @@ def count(self, elem):
         """Returns the number of elements with the specified value"""
         pointer = self._first
         cont = 0
-        while(pointer != None):
+        while pointer != None:
             if pointer.data == elem:
                 cont += 1
             pointer = pointer.next
@@ -120,7 +120,7 @@ def index(self, elem):
         """Returns the index of specified element"""
         pointer = self._first
         cont = 0
-        while(pointer):
+        while pointer:
             if pointer.data == elem:
                 return cont
             else:
@@ -133,7 +133,7 @@ def reverse(self):
         if self._size == 0:
             raise IndexError("Empty list")
         pointer = self._first
-        while(pointer):
+        while pointer:
             pointer.next, pointer.prev = pointer.prev, pointer.next
             pointer = pointer.prev
         self._first, self._last = self._last, self._first
@@ -144,7 +144,7 @@ def createReversed(self):
             raise IndexError("Empty list")
         new = DoublyLinkedList()
         pointer = self._last
-        while(pointer):
+        while pointer:
             new.append(pointer.data)
             pointer = pointer.prev
         return new
@@ -177,12 +177,12 @@ def __delitem__(self, index):
         if index == 0:
             self._first = self._first.next
             self._first.prev = None
-        elif index == self._size-1:
+        elif index == self._size - 1:
             self._last = self._last.prev
             self._last.next = None
         else:
-            node_next = self.getItemByIndex(index+1)
-            node_prev = self.getItemByIndex(index-1)
+            node_next = self.getItemByIndex(index + 1)
+            node_prev = self.getItemByIndex(index - 1)
             node_next.prev = node_prev
             node_prev.next = node_next
         self._size -= 1
@@ -197,7 +197,7 @@ def __str__(self):
         rep = "\033[1;34mNone\033[0;0m" + " <- {} " + "\033[1;34mNone\033[0;0m"
         pointer = self._first
         aux = ""
-        while(pointer != None):
+        while pointer != None:
             if pointer == self._first and pointer.next is None:
                 aux += "\033[1;31m" + str(pointer.data) + "\033[0;0m" + " -> "
                 break
@@ -206,8 +206,7 @@ def __str__(self):
                 break
             else:
                 if self._first == pointer:
-                    aux += "\033[1;31m" + \
-                        str(pointer.data) + "\033[0;0m" + " <-> "
+                    aux += "\033[1;31m" + str(pointer.data) + "\033[0;0m" + " <-> "
                 else:
                     aux += f"{pointer.data} <-> "
                 pointer = pointer.next

Hash Table.py

@@ -46,16 +46,16 @@ def hashing(self, key, table_size):
         """Transforms a key in index (Division method)"""
         if (isinstance(key, str) and key.isalnum()) or isinstance(key, int):
             if isinstance(key, str):
-                key = Hash.stringProcess(key)
+                key = HashTable.stringProcess(key)
             index = (key & int("0x7FFFFFFF", 16)) % table_size
         else:
             raise Exception("Unsupported type")
         return index
 
     def doubleHashing(self, index, key, count):
         """Apply a new hash function"""
-        new_index = self.hashing(key, self._max-1) + 1
-        return ((index + count*new_index) & int("0x7FFFFFFF", 16)) % self._max
+        new_index = self.hashing(key, self._max - 1) + 1
+        return ((index + count * new_index) & int("0x7FFFFFFF", 16)) % self._max
 
     def reset(self):
         """Restores the hash table to its starting point(Empty)"""
@@ -67,7 +67,10 @@ def processCollisions(self, index, key):
         count = 0
         while True:
             new_index = self.doubleHashing(index, key, count)
-            if self._hash_table[new_index] is None or self._hash_table[new_index].key == key:
+            if (
+                self._hash_table[new_index] is None
+                or self._hash_table[new_index].key == key
+            ):
                 return new_index
             else:
                 index = new_index
@@ -90,16 +93,16 @@ def __getitem__(self, key):
             raise Exception("Hash table is empty")
         index = self.hashing(key, self._max)
         if self._hash_table[index] is None:
-            raise Exception(
-                f"The index corresponding to the key: {key}, is empty")
+            raise Exception(f"The index corresponding to the key: {key}, is empty")
         else:
             if self._hash_table[index].key == key:
                 return self._hash_table[index].data
             else:
                 new_index = self.processCollisions(index, key)
                 if self._hash_table[new_index] is None:
                     raise Exception(
-                        f"The index corresponding to the key: {key}, is empty")
+                        f"The index corresponding to the key: {key}, is empty"
+                    )
                 return self._hash_table[new_index].data
 
     def __len__(self):