From add0b1950514c5851ac74ee6e6099229b1bcb998 Mon Sep 17 00:00:00 2001
From: ivs <ivsucram@gmail.com>
Date: Thu, 27 Feb 2025 19:31:48 +0800
Subject: [PATCH] Tutorial 3

---
 T3/Answer/Q2 - level_order_traversal.py |  99 +++++++++++++++++
 T3/Answer/Q3 - pre_order_iterative.py   | 115 ++++++++++++++++++++
 T3/Answer/Q4 - max_depth.py             | 134 ++++++++++++++++++++++++
 T3/Base/Q2 - level_order_traversal.py   |  88 ++++++++++++++++
 T3/Base/Q3 - pre_order_iterative.py     | 100 ++++++++++++++++++
 T3/Base/Q4 - max_depth.py               | 125 ++++++++++++++++++++++
 6 files changed, 661 insertions(+)
 create mode 100644 T3/Answer/Q2 - level_order_traversal.py
 create mode 100644 T3/Answer/Q3 - pre_order_iterative.py
 create mode 100644 T3/Answer/Q4 - max_depth.py
 create mode 100644 T3/Base/Q2 - level_order_traversal.py
 create mode 100644 T3/Base/Q3 - pre_order_iterative.py
 create mode 100644 T3/Base/Q4 - max_depth.py

diff --git a/T3/Answer/Q2 - level_order_traversal.py b/T3/Answer/Q2 - level_order_traversal.py
new file mode 100644
index 0000000..f29ef3b
--- /dev/null
+++ b/T3/Answer/Q2 - level_order_traversal.py	
@@ -0,0 +1,99 @@
+class Bst_node:
+    def __init__(self, item):
+        self.item = item
+        self.left = None
+        self.right = None
+
+class Queue_node:
+    def __init__(self, data):
+        self.data = data
+        self.next_ptr = None
+
+class Queue:
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+def insert_bst_node(node_ref, value):
+    if node_ref[0] is None:
+        node_ref[0] = Bst_node(value)
+    else:
+        if value < node_ref[0].item:
+            if node_ref[0].left is None:
+                node_ref[0].left = Bst_node(value)
+            else:
+                insert_bst_node([node_ref[0].left], value)
+        elif value > node_ref[0].item:
+            if node_ref[0].right is None:
+                node_ref[0].right = Bst_node(value)
+            else:
+                insert_bst_node([node_ref[0].right], value)
+
+def enqueue(queue, node):
+    new_node = Queue_node(node)
+
+    if is_empty(queue.head):
+        queue.head = new_node
+    else:
+        queue.tail.next_ptr = new_node
+
+    queue.tail = new_node
+
+def dequeue(queue):
+    if queue.head is not None:
+        node = queue.head.data
+        queue.head = queue.head.next_ptr
+        if queue.head is None:  # If the queue becomes empty
+            queue.tail = None
+        return node
+    return None
+
+def is_empty(head):
+    return head is None
+
+def remove_all(node_ref):
+    if node_ref[0] is not None:
+        remove_all([node_ref[0].left])
+        remove_all([node_ref[0].right])
+        del node_ref[0]
+
+def level_order_traversal(root):
+    queue = Queue()
+    temp = root
+
+    if temp is not None:
+        enqueue(queue, temp)
+        while not is_empty(queue.head):
+            temp = dequeue(queue)
+            print(temp.item, end=' ')
+            if temp.left is not None:
+                enqueue(queue, temp.left)
+            if temp.right is not None:
+                enqueue(queue, temp.right)
+
+# Main function to run the program.
+if __name__ == "__main__":
+    c = 1
+    root = [None]  # Use a list to allow modification of the root reference
+
+    print("1: Insert an integer into the binary search tree;")
+    print("2: Print the level-order traversal of the binary search tree;")
+    print("0: Quit;")
+
+    while c != 0:
+        c = int(input("Please input your choice(1/2/0): "))
+
+        if c == 1:
+            i = int(input("Input an integer that you want to insert into the Binary Search Tree: "))
+            insert_bst_node(root, i)
+
+        elif c == 2:
+            print("The resulting level-order traversal of the binary search tree is: ", end="")
+            level_order_traversal(root[0])  # Pass the actual root node
+            print()
+
+        elif c == 0:
+            remove_all(root)
+
+        else:
+            print("Choice unknown;")
\ No newline at end of file
diff --git a/T3/Answer/Q3 - pre_order_iterative.py b/T3/Answer/Q3 - pre_order_iterative.py
new file mode 100644
index 0000000..dc41aca
--- /dev/null
+++ b/T3/Answer/Q3 - pre_order_iterative.py	
@@ -0,0 +1,115 @@
+class Bst_node:
+    def __init__(self, item):
+        self.item = item
+        self.left = None
+        self.right = None
+
+class Stack_node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+class Stack:
+    def __init__(self):
+        self.top = None
+
+def insert_bst_node(node_ref, value):
+    if node_ref[0] is None:
+        node_ref[0] = Bst_node(value)
+    else:
+        if value < node_ref[0].item:
+            if node_ref[0].left is None:
+                node_ref[0].left = Bst_node(value)
+            else:
+                insert_bst_node([node_ref[0].left], value)
+        elif value > node_ref[0].item:
+            if node_ref[0].right is None:
+                node_ref[0].right = Bst_node(value)
+            else:
+                insert_bst_node([node_ref[0].right], value)
+
+def push(stack, node):
+    temp = Stack_node(node)
+
+    if stack.top is None:
+        stack.top = temp
+        temp.next = None
+    else:
+        temp.next = stack.top
+        stack.top = temp
+
+def pop(s):
+    if s.top is None:
+        return None
+
+    temp = s.top.next
+    ptr = s.top.data
+    s.top = temp
+    return ptr
+
+def peek(s):
+    if s.top is None:
+        return None
+    return s.top.data
+
+def isEmpty(s):
+    return s.top is None
+
+def removeAll(node_ref):
+    if node_ref[0] is not None:
+        removeAll([node_ref[0].left])
+        removeAll([node_ref[0].right])
+        node_ref[0] = None
+
+def pre_order_iterative(root):
+    stack = Stack()
+    temp = root
+
+    if temp is None:
+        return
+
+    push(stack, temp)
+
+    while not isEmpty(stack):
+        temp = pop(stack)
+        print(temp.item, end=" ")
+
+        if temp.right is not None:
+            push(stack, temp.right)
+        if temp.left is not None:
+            push(stack, temp.left)
+
+def main():
+    root = [None]  # Using list to simulate pointer reference
+
+    print("1: Insert an integer into the binary search tree;")
+    print("2: Print the pre-order traversal of the binary search tree;")
+    print("0: Quit;")
+
+    while True:
+        try:
+            c = int(input("Please input your choice(1/2/0): "))
+
+            if c == 1:
+                i = int(input("Input an integer that you want to insert into the Binary Search Tree: "))
+                insert_bst_node(root, i)
+
+            elif c == 2:
+                print("The resulting pre-order traversal of the binary search tree is: ", end="")
+                pre_order_iterative(root[0])
+                print()
+
+            elif c == 0:
+                removeAll(root)
+                break
+
+            else:
+                print("Choice unknown;")
+
+        except ValueError:
+            print("Invalid input")
+            continue
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/T3/Answer/Q4 - max_depth.py b/T3/Answer/Q4 - max_depth.py
new file mode 100644
index 0000000..c331a0c
--- /dev/null
+++ b/T3/Answer/Q4 - max_depth.py	
@@ -0,0 +1,134 @@
+class Bt_node:
+    def __init__(self, item):
+        self.item = item
+        self.left = None
+        self.right = None
+
+class Stack_node:
+    def __init__(self, btnode):
+        self.btnode = btnode
+        self.next = None
+
+class Stack:
+    def __init__(self):
+        self.top = None
+
+def create_bt_node(item):
+    return Bt_node(item)
+
+def push(stack, node):
+    temp = Stack_node(node)
+    if stack.top is None:
+        stack.top = temp
+        temp.next = None
+    else:
+        temp.next = stack.top
+        stack.top = temp
+
+def pop(stack):
+    if stack.top is None:
+        return None
+
+    temp = stack.top.next
+    ptr = stack.top.btnode
+    stack.top = temp
+    return ptr
+
+def print_tree(node):
+    if node is None:
+        return
+    print_tree(node.left)
+    print(node.item, end=" ")
+    print_tree(node.right)
+
+def create_tree():
+    stack = Stack()
+    root = None
+
+    print("Input an integer that you want to add to the binary tree. Any Alpha value will be treated as NULL.")
+    try:
+        item = input("Enter an integer value for the root: ")
+        root = create_bt_node(int(item))
+        push(stack, root)
+    except ValueError:
+        return None
+
+    while True:
+        temp = pop(stack)
+        if temp is None:
+            break
+
+        try:
+            item = input(f"Enter an integer value for the Left child of {temp.item}: ")
+            temp.left = create_bt_node(int(item))
+        except ValueError:
+            temp.left = None
+
+        try:
+            item = input(f"Enter an integer value for the Right child of {temp.item}: ")
+            temp.right = create_bt_node(int(item))
+        except ValueError:
+            temp.right = None
+
+        if temp.right is not None:
+            push(stack, temp.right)
+        if temp.left is not None:
+            push(stack, temp.left)
+
+    return root
+
+def remove_all(node):
+    if node is not None:
+        remove_all(node.left)
+        remove_all(node.right)
+        node.left = None
+        node.right = None
+
+def max_depth(node):
+    if node is None:
+        return -1
+    else:
+        left_depth = max_depth(node.left)
+        right_depth = max_depth(node.right)
+
+        if left_depth > right_depth:
+            return left_depth + 1
+        else:
+            return right_depth + 1
+
+def main():
+    root = None
+
+    print("1: Create a binary tree.")
+    print("2: Find the maximum depth of the binary tree.")
+    print("0: Quit;")
+
+    while True:
+        try:
+            c = int(input("\nPlease input your choice(1/2/0): "))
+
+            if c == 1:
+                root = None  # Clear existing tree
+                root = create_tree()
+                print("The resulting binary tree is: ", end="")
+                print_tree(root)
+                print()
+
+            elif c == 2:
+                depth = max_depth(root)
+                print(f"The maximum depth of the binary tree is: {depth}")
+                root = None
+
+            elif c == 0:
+                if root:
+                    remove_all(root)
+                break
+
+            else:
+                print("Choice unknown;")
+
+        except ValueError:
+            continue
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/T3/Base/Q2 - level_order_traversal.py b/T3/Base/Q2 - level_order_traversal.py
new file mode 100644
index 0000000..2c05002
--- /dev/null
+++ b/T3/Base/Q2 - level_order_traversal.py	
@@ -0,0 +1,88 @@
+class Bst_node:
+    def __init__(self, item):
+        self.item = item
+        self.left = None
+        self.right = None
+
+class Queue_node:
+    def __init__(self, data):
+        self.data = data
+        self.next_ptr = None
+
+class Queue:
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+def insert_bst_node(node_ref, value):
+    if node_ref[0] is None:
+        node_ref[0] = Bst_node(value)
+    else:
+        if value < node_ref[0].item:
+            if node_ref[0].left is None:
+                node_ref[0].left = Bst_node(value)
+            else:
+                insert_bst_node([node_ref[0].left], value)
+        elif value > node_ref[0].item:
+            if node_ref[0].right is None:
+                node_ref[0].right = Bst_node(value)
+            else:
+                insert_bst_node([node_ref[0].right], value)
+
+def enqueue(queue, node):
+    new_node = Queue_node(node)
+
+    if is_empty(queue.head):
+        queue.head = new_node
+    else:
+        queue.tail.next_ptr = new_node
+
+    queue.tail = new_node
+
+def dequeue(queue):
+    if queue.head is not None:
+        node = queue.head.data
+        queue.head = queue.head.next_ptr
+        if queue.head is None:  # If the queue becomes empty
+            queue.tail = None
+        return node
+    return None
+
+def is_empty(head):
+    return head is None
+
+def remove_all(node_ref):
+    if node_ref[0] is not None:
+        remove_all([node_ref[0].left])
+        remove_all([node_ref[0].right])
+        del node_ref[0]
+
+def level_order_traversal(root):
+    raise NotImplementedError
+
+# Main function to run the program.
+if __name__ == "__main__":
+    c = 1
+    root = [None]  # Use a list to allow modification of the root reference
+
+    print("1: Insert an integer into the binary search tree;")
+    print("2: Print the level-order traversal of the binary search tree;")
+    print("0: Quit;")
+
+    while c != 0:
+        c = int(input("Please input your choice(1/2/0): "))
+
+        if c == 1:
+            i = int(input("Input an integer that you want to insert into the Binary Search Tree: "))
+            insert_bst_node(root, i)
+
+        elif c == 2:
+            print("The resulting level-order traversal of the binary search tree is: ", end="")
+            level_order_traversal(root[0])  # Pass the actual root node
+            print()
+
+        elif c == 0:
+            remove_all(root)
+
+        else:
+            print("Choice unknown;")
\ No newline at end of file
diff --git a/T3/Base/Q3 - pre_order_iterative.py b/T3/Base/Q3 - pre_order_iterative.py
new file mode 100644
index 0000000..38a8837
--- /dev/null
+++ b/T3/Base/Q3 - pre_order_iterative.py	
@@ -0,0 +1,100 @@
+class Bst_node:
+    def __init__(self, item):
+        self.item = item
+        self.left = None
+        self.right = None
+
+class Stack_node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+class Stack:
+    def __init__(self):
+        self.top = None
+
+def insert_bst_node(node_ref, value):
+    if node_ref[0] is None:
+        node_ref[0] = Bst_node(value)
+    else:
+        if value < node_ref[0].item:
+            if node_ref[0].left is None:
+                node_ref[0].left = Bst_node(value)
+            else:
+                insert_bst_node([node_ref[0].left], value)
+        elif value > node_ref[0].item:
+            if node_ref[0].right is None:
+                node_ref[0].right = Bst_node(value)
+            else:
+                insert_bst_node([node_ref[0].right], value)
+
+def push(stack, node):
+    temp = Stack_node(node)
+
+    if stack.top is None:
+        stack.top = temp
+        temp.next = None
+    else:
+        temp.next = stack.top
+        stack.top = temp
+
+def pop(s):
+    if s.top is None:
+        return None
+
+    temp = s.top.next
+    ptr = s.top.data
+    s.top = temp
+    return ptr
+
+def peek(s):
+    if s.top is None:
+        return None
+    return s.top.data
+
+def isEmpty(s):
+    return s.top is None
+
+def removeAll(node_ref):
+    if node_ref[0] is not None:
+        removeAll([node_ref[0].left])
+        removeAll([node_ref[0].right])
+        node_ref[0] = None
+
+def pre_order_iterative(root):
+    raise NotImplementedError
+
+def main():
+    root = [None]  # Using list to simulate pointer reference
+
+    print("1: Insert an integer into the binary search tree;")
+    print("2: Print the pre-order traversal of the binary search tree;")
+    print("0: Quit;")
+
+    while True:
+        try:
+            c = int(input("Please input your choice(1/2/0): "))
+
+            if c == 1:
+                i = int(input("Input an integer that you want to insert into the Binary Search Tree: "))
+                insert_bst_node(root, i)
+
+            elif c == 2:
+                print("The resulting pre-order traversal of the binary search tree is: ", end="")
+                pre_order_iterative(root[0])
+                print()
+
+            elif c == 0:
+                removeAll(root)
+                break
+
+            else:
+                print("Choice unknown;")
+
+        except ValueError:
+            print("Invalid input")
+            continue
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/T3/Base/Q4 - max_depth.py b/T3/Base/Q4 - max_depth.py
new file mode 100644
index 0000000..08d52f6
--- /dev/null
+++ b/T3/Base/Q4 - max_depth.py	
@@ -0,0 +1,125 @@
+class Bt_node:
+    def __init__(self, item):
+        self.item = item
+        self.left = None
+        self.right = None
+
+class Stack_node:
+    def __init__(self, btnode):
+        self.btnode = btnode
+        self.next = None
+
+class Stack:
+    def __init__(self):
+        self.top = None
+
+def create_bt_node(item):
+    return Bt_node(item)
+
+def push(stack, node):
+    temp = Stack_node(node)
+    if stack.top is None:
+        stack.top = temp
+        temp.next = None
+    else:
+        temp.next = stack.top
+        stack.top = temp
+
+def pop(stack):
+    if stack.top is None:
+        return None
+
+    temp = stack.top.next
+    ptr = stack.top.btnode
+    stack.top = temp
+    return ptr
+
+def print_tree(node):
+    if node is None:
+        return
+    print_tree(node.left)
+    print(node.item, end=" ")
+    print_tree(node.right)
+
+def create_tree():
+    stack = Stack()
+    root = None
+
+    print("Input an integer that you want to add to the binary tree. Any Alpha value will be treated as NULL.")
+    try:
+        item = input("Enter an integer value for the root: ")
+        root = create_bt_node(int(item))
+        push(stack, root)
+    except ValueError:
+        return None
+
+    while True:
+        temp = pop(stack)
+        if temp is None:
+            break
+
+        try:
+            item = input(f"Enter an integer value for the Left child of {temp.item}: ")
+            temp.left = create_bt_node(int(item))
+        except ValueError:
+            temp.left = None
+
+        try:
+            item = input(f"Enter an integer value for the Right child of {temp.item}: ")
+            temp.right = create_bt_node(int(item))
+        except ValueError:
+            temp.right = None
+
+        if temp.right is not None:
+            push(stack, temp.right)
+        if temp.left is not None:
+            push(stack, temp.left)
+
+    return root
+
+def remove_all(node):
+    if node is not None:
+        remove_all(node.left)
+        remove_all(node.right)
+        node.left = None
+        node.right = None
+
+def max_depth(node):
+    raise NotImplementedError
+
+def main():
+    root = None
+
+    print("1: Create a binary tree.")
+    print("2: Find the maximum depth of the binary tree.")
+    print("0: Quit;")
+
+    while True:
+        try:
+            c = int(input("\nPlease input your choice(1/2/0): "))
+
+            if c == 1:
+                root = None  # Clear existing tree
+                root = create_tree()
+                print("The resulting binary tree is: ", end="")
+                print_tree(root)
+                print()
+
+            elif c == 2:
+                depth = max_depth(root)
+                print(f"The maximum depth of the binary tree is: {depth}")
+                root = None
+
+            elif c == 0:
+                if root:
+                    remove_all(root)
+                break
+
+            else:
+                print("Choice unknown;")
+
+        except ValueError:
+            continue
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file