dokonceni bintree

2024/04/bintree-cv-14h_2.py

+class Node:
+    def __init__(self, data:any) -> None:
+        self.data = data
+        self.left = None
+        self.right = None
+    
+    def __str__(self):
+        return str(self.data)
+    
+class BinTree():
+    def __init__(self) -> None:
+        self.root = None
+
+    def add(self, data) -> bool:
+        if not self.root:
+            self.root = Node(data)
+            return True
+              
+        current_node = self.root
+
+        while current_node:
+            if current_node.data > data:
+                if not current_node.left:
+                    current_node.left = Node(data)
+                    return True
+                current_node = current_node.left
+            elif current_node.data < data:
+                if not current_node.right:
+                    current_node.right = Node(data)
+                    return True
+                current_node = current_node.right
+            else:
+                return False
+        
+    def print_recursive(self, node:Node):
+        if not node:
+            return
+        self.print_recursive(node.left)
+        print(node.data, end = " ")
+        self.print_recursive(node.right)
+
+    def print(self):
+        self.print_recursive(self.root)
+        print()
+
+    def find(self, data) -> tuple[Node, Node]:
+        prev = None
+        current_node = self.root
+
+        while current_node:
+            if current_node.data > data:
+                prev = current_node
+                current_node = current_node.left
+            elif current_node.data < data:
+                prev = current_node
+                current_node = current_node.right
+            else:
+                break
+        
+        return prev, current_node
+
+    def remove_leaf(self, prev:Node, current:Node):
+        if prev == None:
+            self.root = None
+            return
+        if prev.left == current:
+            prev.left = None
+        else:
+            prev.right = None
+
+    def remove_in_branch(self, prev:Node, current:Node):
+        if prev==None:
+            if current.left == None:
+                self.root = current.right
+            else:
+                self.root = current.left
+            return
+        if current == prev.left:
+            if current.left:
+                prev.left = current.left
+            else:
+                prev.left = current.right
+        else:
+            prev.right = current.right if current.right else current.left
+
+    def remove_in_tree(self, current:Node):
+        tmp = current.left
+        tmp_prev = current
+
+        while tmp.right:
+            tmp_prev = tmp
+            tmp = tmp.right
+        
+        current.data = tmp.data
+
+        if tmp.left:
+            self.remove_in_branch(tmp_prev, tmp)
+        else:
+            self.remove_leaf(tmp_prev, tmp)
+    
+    def remove(self, data) -> bool:
+        prev, current_node = self.find(data)
+        if not current_node:
+            return False
+        if current_node.left and current_node.right:
+            self.remove_in_tree(current_node)
+        elif current_node.left or current_node.right:
+            self.remove_in_branch(prev, current_node)
+        else:
+            self.remove_leaf(prev, current_node)
+        return True
+    
+    def find_data(self, data) -> bool:
+        prev, current = self.find(data)
+        if current:
+            return True
+        else:
+            return False
+    
+tree = BinTree()
+
+tree.add(10)
+tree.add(5)
+tree.add(11)
+tree.add(1)
+tree.add(6)
+tree.add(0)
+tree.add(7)
+tree.add(12)
+tree.add(13)
+
+tree.print()
+#tree.remove(6)
+
+print(tree.find_data(10))
+print(tree.find_data(13))
+print(tree.find_data(1))
+print(tree.find_data(999))
+
+print("-------------------")
+tree.print()
+            
\ No newline at end of file

2024/04/bintree-cv-16h_2.py

+class Node:
+    def __init__(self, data) -> None:
+        self.data = data
+        self.left = None
+        self.right = None
+
+    def __str__(self) -> str:
+        return str(self.data)
+    
+class BinTree:
+    def __init__(self, l:list = []) -> None:
+        self.root = None
+        for x in l:
+            self.add(x)
+
+    def add(self, data) -> bool:
+        if not self.root:
+            self.root = Node(data)
+            return True
+
+        current_node = self.root
+
+        while current_node:
+            if data < current_node.data:
+                if not current_node.left:
+                    current_node.left = Node(data)
+                    return True
+                current_node = current_node.left
+            elif data > current_node.data:
+                if not current_node.right:
+                    current_node.right = Node(data)
+                    return True
+                current_node = current_node.right
+            else:
+                return False
+        return False   
+
+    def print_recursive(self, node:Node):
+        if not node:
+            return
+        self.print_recursive(node.left)
+        print(node, end=" ")
+        self.print_recursive(node.right) 
+        
+    def print(self):
+        self.print_recursive(self.root)
+        print()
+
+    def find(self, data) -> tuple[Node, Node]:
+        prev = None
+        current_node = self.root
+
+        while current_node:
+            if data < current_node.data:
+                prev = current_node
+                current_node = current_node.left
+            elif data > current_node.data:
+                prev = current_node
+                current_node = current_node.right
+            else:
+                break
+        return prev, current_node
+    
+    def remove_leaf(self, prev:Node, current_node:Node) -> None:
+        if prev == None:
+            self.root = None
+            return
+
+        if current_node == prev.right:
+            prev.right = None
+        else:
+            prev.left = None
+        
+    def remove_branch(self, prev:Node, current_node:Node) -> None:
+        if prev == None:
+            if self.root.left:
+               self.root = self.root.left
+            else:
+               self.root = self.root.right
+            return
+        if current_node == prev.right:
+            if current_node.right:
+                prev.right = current_node.right
+            else:
+                prev.right = current_node.left
+        else:
+            prev.left = current_node.left if current_node.left else current_node.right
+        
+    def remove_double_branch(self, current_node:Node) -> None:  
+        tmp = current_node.left
+        tmp_prev = current_node
+
+        while tmp.right:
+            tmp_prev = tmp
+            tmp = tmp.right
+        
+        current_node.data = tmp.data
+
+        if tmp.left == None:
+            self.remove_leaf(tmp_prev, tmp)
+        else:
+            self.remove_branch(tmp_prev, tmp)
+
+    def remove(self, data) -> bool:
+        prev, current_node = self.find(data)
+        if current_node == None:
+            return False
+
+        if current_node.left==None and current_node.right==None:
+            self.remove_leaf(prev, current_node)
+        elif current_node.left and current_node.right:
+            self.remove_double_branch(current_node)
+        else:
+            self.remove_branch(prev, current_node)
+        return True
+    
+    def is_found(self, data) -> bool:
+        prev, current_node = self.find(data)
+        if current_node:
+            return True
+        else:
+            return False
+
+tree = BinTree([10,5,7,11,15,1,6, 6.5])
+tree.print()
+
+tree.remove(999)
+
+print(tree.is_found(5))
+print(tree.is_found(6.5))
+print(tree.is_found(11))
+print(tree.is_found(99))
+
+tree.print()
+
+
+