Trees in Python

Tree Data Structure is a non-linear data structure in which a collection of elements known as nodes are connected to each other via edges such that there exists exactly one path between any two nodes. Trees are used in many areas of computer science, including file systems, databases and even artificial intelligence.

Basic Terminologies In Tree Data Structure

• Parent Node: The node which is an immediate predecessor of a node is called the parent node of that node. {B} is the parent node of {D, E}.
• Child Node: The node which is the immediate successor of a node is called the child node of that node. Examples: {D, E} are the child nodes of {B}.
• Root Node: The topmost node of a tree or the node which does not have any parent node is called the root node. {A} is the root node of the tree. A non-empty tree must contain exactly one root node and exactly one path from the root to all other nodes of the tree.
• Leaf Node or External Node: The nodes which do not have any child nodes are called leaf nodes. {I, J, K, F, G, H} are the leaf nodes of the tree.
• Ancestor of a Node: Any predecessor nodes on the path of the root to that node are called Ancestors of that node. {A,B} are the ancestor nodes of the node {E}
• Descendant: A node x idns a descendant of another node y if and only if y is an ancestor of x.
• Sibling: Children of the same parent node are called siblings. {D,E} are called siblings.
• Level of a node: The count of edges on the path from the root node to that node. The root node has level 0.
• Internal node: A node with at least one child is called Internal Node.
• Neighbour of a Node: Parent or child nodes of that node are called neighbors of that node.
• Subtree: Any node of the tree along with its descendant.

Representation of a Node in Tree Data Structure

A tree can be represented using a collection of nodes. Each of the nodes can be represented with the help of class or structs. Below is the Python representation of Node:

Types of Tree data structure

Different type of Tree Data Structure are following:

1. Binary Tree

Binary Tree is a non-linear and hierarchical data structure where each node has at most two children referred to as the left child and the right child. The topmost node in a binary tree is called the root and the bottom-most nodes are called leaves.

Explore in detail about Binary Tree in Python

2. Binary Search Tree

A Binary Search Tree (or BST) is a data structure used in computer science for organizing and storing data in a sorted manner. Each node in a Binary Search Tree has at most two children, a left child and a right child, with the left child containing values less than the parent node and the right child containing values greater than the parent node. This hierarchical structure allows for efficient searching, insertion and deletion operations on the data stored in the tree.

Explore in detail about Binary Search Tree in Python

3. AVL Tree

The AVL tree is a self–balancing binary search tree that guarantees the difference of the heights of the left and right subtrees of a node is at most 1. The algorithm is named after its inventors, Georgy Adelson-Velsky and Evgenii Landis who published their paper in 1962.

The AVL tree keeps its balance through rotations subsequently after adding or removing nodes. This rotation mechanism balances the tree and allocates resources for the best depth search, insertion and removal procedures.

In Python, AVL trees are implemented usually through classes. The structure respectively contains nodes representing individual elements and methods for insertion, deletion and rotation to preserve the balance. This data structure shows its usage in the fields where fast search, insertion and deleting operations are needed to maintain equilibrium and avoid problems.

Explore in detail about AVL Tree in Python

4. Red Black Tree

Red Black Trees are a type of balanced binary search tree that use a set of rules to maintain balance, ensuring logarithmic time complexity for operations like insertion, deletion and searching, regardless of the initial shape of the tree. Red Black Trees are self-balancing, using a simple color-coding scheme to adjust the tree after each modification.

Explore in detail about Red Black Tree in Python

5. B-Tree

A B-Tree is a specialized m-way tree designed to optimize data access, especially on disk-based storage systems.

• In a B-Tree of order m, each node can have up to m children and m-1 keys, allowing it to efficiently manage large datasets.
• The value of m is decided based on disk block and key sizes.
• One of the standout features of a B-Tree is its ability to store a significant number of keys within a single node, including large key values. It significantly reduces the tree’s height, hence reducing costly disk operations.
• B Trees allow faster data retrieval and updates, making them an ideal choice for systems requiring efficient and scalable data management. By maintaining a balanced structure at all times,
• B-Trees deliver consistent and efficient performance for critical operations such as search, insertion and deletion.

Explore in detail about B Tree in Python

6. B+ Tree

B + Tree is a variation of the B-tree data structure. In a B + tree, data pointers are stored only at the leaf nodes of the tree. In a B+ tree structure of a leaf node differs from the structure of internal nodes. The leaf nodes have an entry for every value of the search field, along with a data pointer to the record (or to the block that contains this record). The leaf nodes of the B+ tree are linked together to provide ordered access to the search field to the records. Internal nodes of a B+ tree are used to guide the search. Some search field values from the leaf nodes are repeated in the internal nodes of the B+ tree.

Explore in detail about B+ Tree in Python

Properties of Tree Data Structure

Number of edges: An edge can be defined as the connection between two nodes. If a tree has N nodes then it will have (N-1) edges. There is only one path from each node to any other node of the tree.

Depth of a node: The depth of a node is defined as the length of the path from the root to that node. Each edge adds 1 unit of length to the path. So, it can also be defined as the number of edges in the path from the root of the tree to the node.

• Height of a node: The height of a node can be defined as the length of the longest path from the node to a leaf node of the tree.
• Height of the Tree: The height of a tree is the length of the longest path from the root of the tree to a leaf node of the tree.
• Degree of a Node: The total count of subtrees attached to that node is called the degree of the node. The degree of a leaf node must be 0. The degree of a tree is the maximum degree of a node among all the nodes in the tree.

Implementation of Tree in Python

The parents of each node are:
1->Root
2->1
5->2
6->2
3->1
4->1
7->4
The children of each node are:
1->
2
3
4

2->
5
6

3->

4->
7

5->

6->

7->

The leaf nodes of the tree are:
3
5
6
7
The degrees of...

Tree Traversal Techniques

Tree Traversal refers to the process of visiting each node in a tree exactly once in a specific order. Traversal is essential for various tree operations, such as searching, inserting and deleting nodes. There are several types of tree traversal, including:

1. Inorder Traversal in Tree
2. Preorder Traversal in Tree
3. Postorder Traversal in Tree

Explore in detail about Tree Traversal Techniques in Python