BASIC DATA STRUCTURE AND ALGORITHM

Author: wesley-94

AVL_BST.py renamed to Python_DataStructure_Algorithm_Basic/AVL_BST.py

@@ -0,0 +1,31 @@
+from transversal_BST_recursively import BSTwithTransversalRecursively
+
+def find_ancestor(path, low_value, high_value):
+    while path:
+        current_value = path[0]
+        if current_value < low_value:
+            try:
+                path = path[2:]
+            except:
+                return current_value
+        elif current_value > high_value:
+            try:
+                path = path[1:]
+            except:
+                return current_value
+        elif low_value <= current_value <= high_value:
+            return current_value
+
+
+if __name__ == "__main__":
+    bst = BSTwithTransversalRecursively()
+    l = [10,5,6,3,8,2,1,11,9,4]
+    for i in l:
+        bst.add_node(i)
+    path = bst.preorder()
+    print("전위 순회: ", path)
+
+    print("1과 6의 최소 공통 조상 :", find_ancestor(path, 1, 6))
+    print("1과 11의 최소 공통 조상 :", find_ancestor(path, 1, 11))
+    print("1과 4의 최소 공통 조상 :", find_ancestor(path, 1, 4))
+    print("8과 9의 최소 공통 조상 : ", find_ancestor(path, 8, 9))

BT_lists.py renamed to Python_DataStructure_Algorithm_Basic/BT_lists.py

@@ -0,0 +1,75 @@
+from collections import deque
+from binary_search_tree import BinarySearchTree, NodeBST
+
+class BSTwithTransversalIterative(BinarySearchTree):
+
+    def inorder(self):
+        current = self.root
+        nodes, stack = [], []
+        while stack or current:
+            if current:
+                stack.append(current)
+                current = current.left
+            else:
+                current = stack.pop()
+                nodes.append(current.value)
+                current = current.right
+        return nodes
+
+    def preorder(self):
+        current = self.root
+        nodes, stack = [], []
+        while stack or current:
+            if current:
+                nodes.append(current.value)
+                stack.append(current)
+                current = current.left
+            else:
+                current = stack.pop()
+                current = current.right
+        return nodes
+
+    def preorder2(self):
+        nodes = []
+        stack = [self.root]
+        while stack:
+            current = stack.pop()
+            if current:
+                nodes.append(current.value)
+                stack.append(current.right)
+                stack.append(current.left)
+        return nodes
+    
+    def BFT(self):
+        current = self.root
+        nodes = []
+        queue = deque()
+        queue.append(current)
+        while queue:
+            current = queue.popleft()
+            nodes.append(current.value)
+            if current.left:
+                queue.append(current.left)
+            if current.right:
+                queue.append(current.right)
+        return nodes
+
+    
+if __name__ == "__main__":
+    bst = BSTwithTransversalIterative()
+    l = [10,5,6,3,8,2,1,11,9,4]
+    for i in l:
+        bst.add_node(i)
+
+    print("노드 8은 말단 노드입니까? ", bst.is_leaf(8))
+    print("노드 8의 레벨은? ", bst.get_node_level(8))
+    print("노드 10은 루트 노드입니까? ", bst.is_root(10))
+    print("노드 1은 루트 노드입니까? ", bst.is_root(1))
+    print("트리의 높이는? ", bst.get_height())
+    print("이진 탐색 트리입니까? ", bst.is_bst())
+    print("균형 트리입니까? ", bst.is_balanced())
+
+    print("전위 순회: ", bst.preorder())
+    print("전위 순회2: ", bst.preorder2())
+    print("중위 순회: ", bst.inorder())
+    print("너비 우선 탐색: ", bst.BFT())

ShapeClass.py renamed to Python_DataStructure_Algorithm_Basic/ShapeClass.py

@@ -0,0 +1,79 @@
+from binary_search_tree import BinarySearchTree, NodeBST
+
+
+class BSTwithTransversalRecursively(BinarySearchTree):
+
+    def __init__(self):
+        self.root = None
+        self.nodes_BFS = []
+        self.nodes_pre = []
+        self.nodes_post = []
+        self.nodes_in = []
+
+    def BFT(self):
+        self.root.level = 1
+        queue = [self.root]
+        current_level = self.root.level
+
+        while len(queue) > 0:
+            current_node = queue.pop(0)
+            if current_node.level > current_level:
+                current_level += 1
+            self.nodes_BFS.append(current_node.value)
+
+            if current_node.left:
+                current_node.left.level = current_level + 1
+                queue.append(current_node.left)
+
+            if current_node.right:
+                current_node.right.level = current_level + 1
+                queue.append(current_node.right)
+
+        return self.nodes_BFS
+
+    def inorder(self, node=None, level=1):
+        if not node and level == 1:
+            node = self.root
+        if node:
+            self.inorder(node.left, level+1)
+            self.nodes_in.append(node.value)
+            self.inorder(node.right, level+1)
+        return self.nodes_in
+
+    def preorder(self, node=None, level=1):
+        if not node and level == 1:
+            node = self.root
+        if node:
+            self.nodes_pre.append(node.value)
+            self.preorder(node.left, level+1)
+            self.preorder(node.right, level+1)
+        return self.nodes_pre
+
+    def postorder(self, node=None, level=1):
+        if not node and level == 1:
+            node = self.root
+        if node:
+            self.postorder(node.left, level+1)
+            self.postorder(node.right, level+1)
+            self.nodes_post.append(node.value)
+        return self.nodes_post
+
+
+if __name__ == "__main__":
+    bst = BSTwithTransversalRecursively()
+    l = [10,5,6,3,8,2,1,11,9,4]
+    for i in l:
+        bst.add_node(i)
+
+    print("노드 8은 말단 노드입니까? ", bst.is_leaf(8))
+    print("노드 8의 레벨은? ", bst.get_node_level(8))
+    print("노드 10은 루트 노드입니까? ", bst.is_root(10))
+    print("노드 1은 루트 노드입니까? ", bst.is_root(1))
+    print("트리의 높이는? ", bst.get_height())
+    print("이진 탐색 트리입니까? ", bst.is_bst())
+    print("균형 트리입니까? ", bst.is_balanced())
+
+    print("전위 순회: ", bst.preorder())
+    print("후위 순회: ", bst.postorder())
+    print("중위 순회: ", bst.inorder())
+    print("너비 우선 탐색: ", bst.BFT())