```
# Binary Tree Node class
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
# Binary Tree class with basic features
class BinaryTree:
def __init__(self):
self.root = None
# Insert a new node into the binary tree
def insert(self, value):
if self.root is None:
self.root = TreeNode(value)
else:
self._insert_recursive(self.root, value)
def _insert_recursive(self, node, value):
if value < node.value:
if node.left is None:
node.left = TreeNode(value)
else:
self._insert_recursive(node.left, value)
else:
if node.right is None:
node.right = TreeNode(value)
else:
self._insert_recursive(node.right, value)
# Inorder traversal (Left, Root, Right)
def inorder_traversal(self):
return self._inorder(self.root, [])
def _inorder(self, node, result):
if node:
self._inorder(node.left, result)
result.append(node.value)
self._inorder(node.right, result)
return result
# Preorder traversal (Root, Left, Right)
def preorder_traversal(self):
return self._preorder(self.root, [])
def _preorder(self, node, result):
if node:
result.append(node.value)
self._preorder(node.left, result)
self._preorder(node.right, result)
return result
# Postorder traversal (Left, Right, Root)
def postorder_traversal(self):
return self._postorder(self.root, [])
def _postorder(self, node, result):
if node:
self._postorder(node.left, result)
self._postorder(node.right, result)
result.append(node.value)
return result
# Find height of the binary tree
def find_height(self):
return self._find_height(self.root)
def _find_height(self, node):
if node is None:
return -1 # Return -1 for null nodes
left_height = self._find_height(node.left)
right_height = self._find_height(node.right)
return 1 + max(left_height, right_height)
# Search for a value in the binary tree
def search(self, value):
return self._search_recursive(self.root, value)
def _search_recursive(self, node, value):
if node is None or node.value == value:
return node
if value < node.value:
return self._search_recursive(node.left, value)
else:
return self._search_recursive(node.right, value)
# Find the minimum value in the binary tree
def find_min(self):
if self.root is None:
return None
current = self.root
while current.left is not None:
current = current.left
return current.value
# Find the maximum value in the binary tree
def find_max(self):
if self.root is None:
return None
current = self.root
while current.right is not None:
current = current.right
return current.value
# Example usage of BinaryTree class
if __name__ == "__main__":
tree = BinaryTree()
# Insert nodes
values_to_insert = [50, 30, 20, 40, 70, 60, 80]
for value in values_to_insert:
tree.insert(value)
print("Inorder Traversal:", tree.inorder_traversal()) # [20, 30, 40, 50, 60, 70, 80]
print("Preorder Traversal:", tree.preorder_traversal()) # [50, 30, 20, 40, 70, 60, 80]
print("Postorder Traversal:", tree.postorder_traversal()) # [20, 40, 30, 60, 80, 70, 50]
# Find height
print("Height of the tree:", tree.find_height()) # 2
# Search for a value
search_value = 40
found_node = tree.search(search_value)
print(f"Search for {search_value}: {'Found' if found_node else 'Not Found'}")
# Find minimum and maximum values
print("Minimum value in the tree:", tree.find_min()) # 20
print("Maximum value in the tree:", tree.find_max()) # 80
```

### Benefits of TheCodeground Online IDE

#### Multi-Language Support

TheCodeground Online IDE supports C++, Java, Node.js, Python, and more, making it an incredibly versatile tool for diverse coding needs. This extensive language support allows developers to work on different projects within a single platform.

#### Real-Time Collaboration

Our real-time collaboration feature enables multiple developers to work on the same project simultaneously, enhancing teamwork and productivity. This feature is particularly beneficial for remote teams and pair programming sessions.

#### User-Friendly Interface

Designed with a clean and intuitive interface, TheCodeground Online IDE simplifies coding and debugging processes, making it accessible for users of all skill levels. The ease of use and clear navigation ensure a smooth coding experience.

#### Instant Code Execution

Experience fast and efficient code execution with immediate feedback in the integrated terminal. This feature helps streamline the development process, allowing developers to quickly test and debug their code.

#### Free to Use

Enjoy the full range of features at no cost. TheCodeground Online IDE is completely free, providing a valuable resource for developers without any subscription fees. This makes it an ideal choice for students, hobbyists, and professionals alike.

#### Cloud-Based Platform

As a cloud-based IDE, TheCodeground allows you to access your projects from anywhere, at any time. This flexibility ensures that you can continue coding without being tied to a specific device or location.

#### Customizable Environment

Tailor the IDE to your preferences with customizable themes, layouts, and extensions. This personalization ensures a comfortable and productive coding environment.

### Why Choose TheCodeground Over Other Online IDEs?

TheCodeground Online IDE stands out from the competition with its comprehensive feature set, ease of use, and cost-effectiveness. Unlike many other online IDEs that require subscriptions or offer limited free plans, TheCodeground provides all its features for free. Our multi-language support, real-time collaboration, and advanced debugging tools ensure that you have everything you need for effective development. Additionally, our user-friendly interface and customizable environment make coding a pleasant experience, regardless of your expertise level. Choose TheCodeground Online IDE for a seamless, efficient, and enjoyable coding experience.