Final version

projekt-3-python/Node.py

@@ -1,14 +1,12 @@
-import math
-import math
-
-
 class Node:
+    # Konstruktor klasy
     def __init__(self, value=None):
         self.value = value
-        self.left_child = None
-        self.right_child = None
+        self.left_son = None
+        self.right_son = None
         self.parent = None
 
+    # Metoda wstawiania wartości do drzewa
     def insert_value(self, value):
         # Jeśli węzeł nie ma wartości wstawiamy podaną wartość
         if not self.value:
@@ -23,39 +21,42 @@ def insert_value(self, value):
         rekurencyjnie metodę wstawiania na lewym dziecku. Jeśli węzeł nie ma lewego dziecka, ustawiamy jego wartość
         na węzeł z wstawianą wartością'''
         if value < self.value:
-            if self.left_child:
-                self.left_child.insert_value(value)
-                self.left_child.parent = Node(self.value)
+            if self.left_son:
+                self.left_son.insert_value(value)
+                self.left_son.parent = Node(self.value)
                 return
-            self.left_child = Node(value)
-            self.left_child.parent = Node(self.value)
+            self.left_son = Node(value)
+            self.left_son.parent = Node(self.value)
             return
         '''Jeśli wstawiana wartość jest większa od aktualnej wartości węzła oraz węzeł posiada prawe dziecko wywołujemy
         rekurencyjnie metodę wstawiania na prawym dziecku. Jeśli węzeł nie ma prawego dziecka, ustawiamy jego wartość
         na węzeł z wstawianą wartością'''
 
-        if self.right_child:
-            self.right_child.insert_value(value)
-            self.right_child.parent = Node(self.value)
+        if self.right_son:
+            self.right_son.insert_value(value)
+            self.right_son.parent = Node(self.value)
             return
-        self.right_child = Node(value)
-        self.right_child.parent = Node(self.value)
+        self.right_son = Node(value)
+        self.right_son.parent = Node(self.value)
         return
 
+    # Metoda zwracania najmniejszej wartości
     # Dopóki aktualny węzeł posiada lewe dziecko rekurencyjnie ustawiamy wartość na jego lewe dziecko.
     def get_min_value(self):
         current_node = self
-        while current_node.left_child:
-            current_node = current_node.left_child
+        while current_node.left_son:
+            current_node = current_node.left_son
         return current_node.value
 
+    # Metoda zwracania maksymalnej wartości
     # Dopóki aktualny węzeł posiada prawe dziecko rekurencyjnie ustawiamy wartość na jego prawe dziecko.
     def get_max_value(self):
         current_node = self
-        while current_node.right_child:
-            current_node = current_node.right_child
+        while current_node.right_son:
+            current_node = current_node.right_son
         return current_node.value
 
+    # Metoda zwracania ilości węzłów
     '''Jeśli węzeł nie ma wartości (puste drzewo) zwracamy 0, jeśli ma wartość zliczamy od 1 (liczymy korzeń).
     Jeśli jest lewe dziecko do licznika rekurencyjnie dodajemy wywoływaną na nim metodę zliczania..
     Jeśli jest prawe dziecko do licznika rekurencyjnie dodajemy wywoływaną na nim metodę zliczania.
@@ -65,12 +66,13 @@ def get_node_count(self):
             return 0
 
         counter = 1
-        if self.left_child:
-            counter += self.left_child.get_node_count()
-        if self.right_child:
-            counter += self.right_child.get_node_count()
+        if self.left_son:
+            counter += self.left_son.get_node_count()
+        if self.right_son:
+            counter += self.right_son.get_node_count()
         return counter
 
+    # Metoda szukania wartości w drzewie
     '''Jeśli wartość aktualnego węzła jest równa szukanej wartości zwracamy jego wartość.
     Jeśli szukana wartość jest mniejsza sprawdzamy czy istnieje lewe dziecko,
     jeśli nie, to szukanej wartości nie ma w drzewie,
@@ -86,70 +88,107 @@ def find_value(self, value):
             return True
 
         if value < self.value:
-            if not self.left_child:
+            if not self.left_son:
                 return False
-            return self.left_child.find_value(value)
+            return self.left_son.find_value(value)
 
-        if not self.right_child:
+        if not self.right_son:
             return False
-        return self.right_child.find_value(value)
-
+        return self.right_son.find_value(value)
+
+    # Metoda usuwania wartości z drzewa
+    '''Jeśli w drzewie nie ma wartości, którą chcemy usunąć, wypisujemy, że jej nie ma i zwracamy.
+    Jeśli węzęł nie ma wartości zwracamy go. Jeśli wartość aktualnego węzła jest mniejsza od wartości do usunięcia,
+    jako prawe dziecko ustawiamy prawe dziecko, na którym wykonujemy metodę usuwania.
+    Jeśli wartość aktualnego węzła jest większa robimy to samo tylko na lewym dziecku.
+    Jeśli węzeł nie ma dziecka zwracamy prawe dziecko. Jeśli węzeł nie ma prawego dziecka zwracamy lewe dziecko.
+    Jako wartość minimalna ustawiamy najmniejszą wartość z prawego poddrzewa i przypisujemy ją jako wartość węzłą.
+    Jako prawe dziecko ustawiamy prawe dziecko, na którym wykonujemy metodę usuwania wartości z wartością minimalną
+    jako argumeny. Zwracamy węzęł.'''
     def delete_value(self, value):
-        if not self:
-            return self
+        if not self.find_value(value):
+            print("Number doesn't exist in Tree")
+            return
+        else:
+            if not self.value:
+                return self
 
-        if self.value < value:
-            self.right_child = self.right_child.delete_value(value)
-            return self
+            if self.value < value:
+                self.right_son = self.right_son.delete_value(value)
+                return self
+
+            if self.value > value:
+                self.left_son = self.left_son.delete_value(value)
+                return self
 
-        if self.value > value:
-            self.left_child = self.left_child.delete_value(value)
+            if not self.left_son:
+                return self.right_son
+
+            if not self.right_son:
+                return self.left_son
+
+            min_value = self.right_son.get_min_value()
+            self.value = min_value
+            self.right_son = self.right_son.delete_value(min_value)
             return self
 
-        if not self.left_child:
-            return self.right_child
+    # Metoda wyświetlania drzewa w 2d
+    '''Jeśli węzeł nie ma wartości zwracamy. Do zmiennej dystans dodajemy wysokość. Jeśli prawe dziecko istnieje
+    wykonujemy na nim metodę wyświetlania. Dopóki wysokość jest większa od dystansu w każdej iteracji wyświetlamy spację
+    i do wysokości dodajemy 1. Wypisujemy wartość węzła. Jeśli lewy syn istnieje wykonujemy na nim metodę
+    wyświetlania.'''
+    def display(self, distance=0, height=10):
+        if not self.value:
+            return
 
-        if not self.right_child:
-            return self.left_child
+        distance += height
+        if self.right_son:
+            self.right_son.display(distance, height)
 
-        min_value = self.right_child.get_min_value()
+        while height < distance:
+            print("", end=' ')
+            height += 1
 
-        self.value = min_value
-        self.right_child = self.right_child.delete_value(min_value)
-        return self
+        print(self.value)
 
-    def display(self):
-        pass
+        if self.left_son:
+            self.left_son.display(distance, height)
 
+    # Metoda wyświetlania drzewa preorder
+    '''Wypisujemy wartość aktualnego węzła. Jeśli węzeł ma lewego syna wykonujemy na nim metodę rekurencyjnie.
+    Jeśli węzeł ma prawego syna wykonujemy na nim metodę rekurencyjnie."'''
     def display_preorder(self):
         if not self.parent:
             print("Preorder: ", end='')
         if self.value:
             print(self.value, end=' ')
-        if self.left_child:
-            self.left_child.display_preorder()
-        if self.right_child:
-            self.right_child.display_preorder()
-
+        if self.left_son:
+            self.left_son.display_preorder()
+        if self.right_son:
+            self.right_son.display_preorder()
+
+    # Metoda wyświetlania drzewa inorder
+    '''Jeśli węzeł ma lewego syna wykonujemy na nim metodę rekurencyjnie. Wypisujemy wartość aktualnego węzła.
+    Jeśli węzeł ma prawego syna wykonujemy na nim metodę rekurencyjnie.'''
     def display_inorder(self):
         if not self.parent:
             print("Inorder: ", end='')
-        if self.left_child:
-            self.left_child.display_inorder()
+        if self.left_son:
+            self.left_son.display_inorder()
         if self.value:
             print(self.value, end=' ')
-        if self.right_child:
-            self.right_child.display_inorder()
+        if self.right_son:
+            self.right_son.display_inorder()
 
+    # Metoda wyświetlania drzewa postorder
+    '''Jeśli węzeł ma lewego syna wykonujemy na nim metodę rekurencyjnie.  Wypisujemy wartość aktualnego węzła.
+    Jeśli węzeł ma prawego syna wykonujemy na nim metodę rekurencyjnie.'''
     def display_postorder(self):
         if not self.parent:
             print("Postorder: ", end='')
-        if self.left_child:
-            self.left_child.display_postorder()
-        if self.right_child:
-            self.right_child.display_postorder()
+        if self.left_son:
+            self.left_son.display_postorder()
+        if self.right_son:
+            self.right_son.display_postorder()
         if self.value:
             print(self.value, end=' ')
-
-    def get_height(self):
-        pass

projekt-3-python/main.py

@@ -1,30 +1,36 @@
 from Node import Node
 
 if __name__ == "__main__":
-    Root = Node()
+    Tree = Node()
 
-    numbers = [78, 52, 31, 49, 89, 35, 32, 73, 58, 25, 11, 100, 38, 1, 76, 18, 51, 82, 21]
-    # numbers = [19, 12, 15, 21, 25, 30, 3, 1, 4, 6, 7, 10, 9]
+    # numbers = [37, 28, 25, 37, 26, 17, 34, 36, 50, 47, 48, 46, 60, 58]
+    # numbers = [78, 52, 31, 49, 89, 35, 32, 73, 58, 25, 11, 100, 38, 1, 76, 18, 51, 82, 21, 2, 4, 3, 5, 6, 8, 7]
     # numbers = []
 
-    for i in numbers:
-        Root.insert_value(i)
+    size = int(input("Write how many numbers you want to insert: "))
 
-    # number_to_search = int(input("Write number to find in tree: "))
+    for _ in range(size):
+        number = int(input("Input number: "))
+        Tree.insert_value(number)
 
-    min_value = Root.get_min_value()
-    max_value = Root.get_max_value()
-    # searched_value = Root.find_value(number_to_search)
-    node_count = Root.get_node_count()
-    tree_height = Root.get_height()
+    min_value = Tree.get_min_value()
+    max_value = Tree.get_max_value()
+    node_count = Tree.get_node_count()
+    Tree.display()
 
-    # print(f'Number searched for: {number_to_search}. Does it belong to the tree? {searched_value}')
     print(f'Minimum value in tree: {min_value}')
     print(f'Maximum value in tree: {max_value}')
-    print(f'The number of nodes is: {node_count}')
-    print(f'Tree height: {tree_height}')
-    Root.display_preorder()
+    print(f'Number of nodes is: {node_count}')
+    Tree.display_preorder()
     print()
-    Root.display_inorder()
+    Tree.display_inorder()
     print()
-    Root.display_postorder()
+    Tree.display_postorder()
+    print()
+    number_to_search = int(input("Write number to find in tree: "))
+    searched_value = Tree.find_value(number_to_search)
+    print(f'Number searched for: {number_to_search}. Does it belong to the tree? {searched_value}')
+    print()
+    number_to_delete = int(input("Write number to delete from tree: "))
+    Tree.delete_value(number_to_delete)
+    Tree.display()