-
@@ -6046,6 +6076,380 @@ Anil Raj - 12000
Dinesh Kumar - 15000
Sam Singh - 10000
+
- Root: The root node is the topmost node in the tree hierarchy. In other words, the root node is the one that doesn't have any parent. In the above structure, node numbered 1 is the root node of the tree. If a node is directly linked to some other node, it would be called a parent-child relationship. +
- Child node: If the node is a descendant of any node, then the node is known as a child node. +
- Parent: If the node contains any sub-node, then that node is said to be the parent of that sub-node. +
- Sibling: The nodes that have the same parent are known as siblings. +
- Leaf Node: The node of the tree, which doesn't have any child node, is called a leaf node. A leaf node is the bottom-most node of the tree. There can be any number of leaf nodes present in a general tree. Leaf nodes can also be called external nodes. +
- Internal nodes: A node has atleast one child node known as an internal +
- Ancestor node: An ancestor of a node is any predecessor node on a path from the root to that node. The root node doesn't have any ancestors. In the tree shown in the above image, nodes 1, 2, and 5 are the ancestors of node 10. +
- Descendant: The immediate successor of the given node is known as a descendant of a node. In the above figure, 10 is the descendant of node 5. +
- Recursive data structure: The tree is also known as a recursive data structure. A tree can be defined as recursively because the distinguished node in a tree data structure is known as a root node. The root node of the tree contains a link to all the roots of its subtrees. Recursion means reducing something in a self-similar manner. So, this recursive property of the tree data structure is implemented in various applications. +
- Number of edges: If there are n nodes, then there would n-1 edges. Each arrow in the structure represents the link or path. Each node, except the root node, will have atleast one incoming link known as an edge. There would be one link for the parent-child relationship. +
- Depth of node x: The depth of node x can be defined as the length of the path from the root to the node x. One edge contributes one-unit length in the path. So, the depth of node x can also be defined as the number of edges between the root node and the node x. The root node has 0 depth. +
- Height of node x:The height of node x can be defined as the longest path from the node x to the leaf node. +
Tree Data Structure#
+What is a Tree?#
+A tree is a non-linear abstract data type with a hierarchy-based structure. It consists of nodes (where the data is stored) that are connected via links. The tree data structure stems from a single node called a root node and has subtrees connected to the root.
+
Terms Related to Tree Data Structure#
+Some basic terms related to Tree Data Structure are:
+-
+
Properties of Tree Data Structure
+-
+
Implementation of Tree#
+The tree data structure can be created by creating the nodes dynamically with the help of the pointers. The tree in the memory can be represented as shown below:
+
In Python, the structure of a node can be defined as:
+
+ class Node:
+ def __init__(self, data):
+ self.data = data
+ self.left = None
+ self.right = None
+ The above structure can only be defined for the binary trees because the binary tree can have utmost two children, and generic trees can have more than two children. The structure of the node for generic trees would be different as compared to the binary tree.
+Types of Tree#
+There are various types of trees that are used in different applications. Some of the most common types of trees are:
+-
+
- Binary Tree
- +
- Binary Search Tree +
- AVL Tree +
- Red-Black Tree +
- B Tree +
- B+ Tree +
Binary Tree#
+Here, binary name itself suggests two numbers, i.e., 0 and 1. In a binary tree, each node in a tree can have utmost two child nodes. Here, utmost means whether the node has 0 nodes, 1 node or 2 nodes. Binary Trees are general trees in which the root node can only hold up to maximum 2 subtrees: left subtree and right subtree.
+
+
Tree Traversal#
+Traversal is a process to visit all the nodes of a tree and may print their values too. Because, all nodes are connected via edges (links) we always start from the root (head) node. That is, we cannot randomly access a node in a tree. There are three ways which we use to traverse a tree:
+ ++
Pre-order Traversal#
+In this traversal method, the root node is visited first, then the left subtree and finally the right subtree.
+Algorithm:
+-
+
- Repeat Steps 2 to 4 while TREE != NULL +
- Write TREE.DATA +
- PREORDER(TREE.LEFT) +
- PREORDER(TREE.RIGHT) + [END OF LOOP] + +
- END +
Python Code:
+def Preorder_Traversal(root):
+ if root:
+ print(root.data)
+ Preorder_Traversal(root.left)
+ Preorder_Traversal(root.right)
+Example:
+
Post-order Traversal#
+In this traversal method, the root node is visited last, hence the name. First we traverse the left subtree, then the right subtree and finally the root node.
+Algorithm:
+Until all nodes are traversed- +
-
+
- Recursively traverse left subtree. +
- Recursively traverse right subtree. +
- Visit root node. +
Python Code:
+def Postorder_Traversal(root):
+ if root:
+ Postorder_Traversal(root.left)
+ Postorder_Traversal(root.right)
+ print(root.data)
+Example:
+
Inorder Traversal#
+In this traversal method, the left subtree is visited first, then the root and later the right sub-tree. We should always remember that every node may represent a subtree itself.
+Algorithm:
+-
+
- Recursively traverse left subtree. +
- Visit root node. +
- Recursively traverse right subtree. +
Python Code:
+def Inorder_Traversal(root):
+ if root:
+ Inorder_Traversal(root.left)
+ print(root.data)
+ Inorder_Traversal(root.right)
+Example:
+
Binary Search Tree#
+A binary search tree follows some order to arrange the elements. In a Binary search tree, the value of left node must be smaller than the parent node, and the value of right node must be greater than the parent node. This rule is applied recursively to the left and right subtrees of the root.
+Advantages of BST:
+-
+
- Searching an element in the Binary search tree is easy as we always have a hint that which subtree has the desired element. +
- As compared to array and linked lists, insertion and deletion operations are faster in BST. +
Basic Operations of BST
+ +Searching in BST#
+Searching means to find or locate a specific element or node in a data structure. In Binary search tree, searching a node is easy because elements in BST are stored in a specific order. The steps of searching a node in Binary Search tree are listed as follows
+-
+
- First, compare the element to be searched with the root element of the tree. +
- If root is matched with the target element, then return the node's location. +
- If it is not matched, then check whether the item is less than the root element, if it is smaller than the root element, then move to the left subtree. +
- If it is larger than the root element, then move to the right subtree. +
- Repeat the above procedure recursively until the match is found. +
- If the element is not found or not present in the tree, then return NULL +
Example:
+
Suppose we have to find a number n in the above binary tree. So first we will compare n with the root of the tree. If the n is equal to the root then return the node's location. If n is smaller than the root, search in the left subtree or if n is larger than the root, search in the right subtree. Search recursively in the subtree until the node with same data is found. If not present in the tree, return "NOT FOUND!"
+ +Insertion in BST#
+A new key in BST is always inserted at the leaf. To insert an element in BST, we have to start searching from the root node; if the node to be inserted is less than the root node, then search for an empty location in the left subtree. Else, search for the empty location in the right subtree and insert the data. Insert in BST is similar to searching, as we always have to maintain the rule that the left subtree is smaller than the root, and right subtree is larger than the root.
+Example:
+
Deletion in BST#
+In a binary search tree, we must delete a node from the tree by keeping in mind that the property of BST is not violated. To delete a node from BST, there are three possible situations occur:
+-
+
- The node to be deleted is the leaf node +
- The node to be deleted has only one child +
- The node to be deleted has two children +
The node to be deleted is the leaf node
+It is the simplest case to delete a node in BST. Here, we have to replace the leaf node with NULL and simply free the allocated space.
+
The node to be deleted has only one child
+In this case, we have to replace the target node with its child, and then delete the child node. It means that after replacing the target node with its child node, the child node will now contain the value to be deleted. So, we simply have to replace the child node with NULL and free up the allocated space.
+
The node to be deleted has two children
+This case of deleting a node in BST is a bit complex among other two cases. In such a case, the steps to be followed are listed as follows:
+-
+
- Find the inorder successor of the node to be deleted +
- Replace that node with the inorder successor until the target node is not placed at the leaf node +
- Replace the node with NULL and free up the allocated space +
Complexity of the above operations
+1. Time Complexity
+| Operations | +Best case time complexity | +Average case time complexity | +Worst case time complexity | +
|---|---|---|---|
| Insertion | +O(log n) | +O(log n) | +O(n) | +
| Deletion | +O(log n) | +O(log n) | +O(n) | +
| Searching | +O(log n) | +O(log n) | +O(n) | +
2. Space Complexity
+| Operations | +Space complexity | +
|---|---|
| Insertion | +O(n) | +
| Deletion | +O(n) | +
| Searching | +O(n) | +
AVL Tree#
+AVL Tree can be defined as height balanced binary search tree in which each node is associated with a balance factor which is calculated by subtracting the height of its right sub-tree from that of its left sub-tree.
+Tree is said to be balanced if balance factor of each node is in between -1 to 1, otherwise, the tree will be unbalanced and need to be balanced.
+Balance Factor (k) = height (left(k)) - height (right(k))
+If balance factor of any node is 1, it means that the left sub-tree is one level higher than the right sub-tree.If balance factor of any node is 0, it means that the left sub-tree and right sub-tree contain equal height.If balance factor of any node is -1, it means that the left sub-tree is one level lower than the right sub-tree.
++
Importance of AVL Tree
+AVL tree controls the height of the binary search tree by not letting it to be skewed. The time taken for all operations in a binary search tree of height h is O(h). However, it can be extended to O(n) if the BST becomes skewed (i.e. worst case). By limiting this height to log n, AVL tree imposes an upper bound on each operation to be O(log n) where n is the number of nodes.
++
Operations in AVL:
+1. Insertion in AVL Tree
+Insertion in AVL tree is performed in the same way as it is performed in a binary search tree. However, it may lead to violation in the AVL tree property and therefore the tree may need balancing. The tree can be balanced by applying rotations.
+1. Deletion in AVL Tree
+Deletion can also be performed in the same way as it is performed in a binary search tree. Deletion may also disturb the balance of the tree therefore, various types of rotations are used to rebalance the tree.
++
Complexity of Operations
+| Algorithm | +Average case | +Worst case | +
|---|---|---|
| Space Complexity | +O(n) | +O(n) | +
| Search | +O(log n) | +O(log n) | +
| Insert | +O(log n) | +O(log n) | +
| Delete | +O(log n) | +O(log n) | +
+
AVL Rotations
+Using Insertion and Deletion Operation may disturb the balance of the Tree, therefore we use different AVL Rotations to restore the balance of the Tree
+The four types of AVL Rotations are:
+-
+
- LL Rotation +
- RR Rotation +
- LR Rotation +
- RL Rotation +
+
+
1. LL Rotation
+When BST becomes unbalanced, due to a node is inserted into the left subtree of the left subtree of C, then we perform LL rotation, LL rotation is clockwise rotation, which is applied on the edge below a node having balance factor 2.
+
+
2. RR Rotation
+When BST becomes unbalanced, due to a node is inserted into the right subtree of the right subtree of A, then we perform RR rotation, RR rotation is an anticlockwise rotation, which is applied on the edge below a node having balance factor -2
+
+
3. LR Rotation
+Double rotations are bit tougher than single rotation which has already explained above. LR rotation = RR rotation + LL rotation, i.e., first RR rotation is performed on subtree and then LL rotation is performed on full tree, by full tree we mean the first node from the path of inserted node whose balance factor is other than -1, 0, or 1.
+
+
4. RL Rotation
+Double rotations are bit tougher than single rotation which has already explained above. R L rotation = LL rotation + RR rotation, i.e., first LL rotation is performed on subtree and then RR rotation is performed on full tree, by full tree we mean the first node from the path of inserted node whose balance factor is other than -1, 0, or 1.
+
+
Red-Black Tree#
+The red-Black tree is a binary search tree. The prerequisite of the red-black tree is that we should know about the binary search tree. In a binary search tree, the values of the nodes in the left subtree should be less than the value of the root node, and the values of the nodes in the right subtree should be greater than the value of the root node.
+Each node in the Red-black tree contains an extra bit that represents a color to ensure that the tree is balanced during any operations performed on the tree like insertion, deletion, etc. In a binary search tree, the searching, insertion and deletion take O(log2n) time in the average case, O(1) in the best case and O(n) in the worst case.
++
Properties of Red-Black tree
+-
+
- It is a self-balancing Binary Search tree. Here, self-balancing means that it balances the tree itself by either doing the rotations or recoloring the nodes. +
- This tree data structure is named as a Red-Black tree as each node is either Red or Black in color. Every node stores one extra information known as a bit that represents the color of the node. For example, 0 bit denotes the black color while 1 bit denotes the red color of the node. Other information stored by the node is similar to the binary tree, i.e., data part, left pointer and right pointer. +
- In the Red-Black tree, the root node is always black in color. +
- In a binary tree, we consider those nodes as the leaf which have no child. In contrast, in the Red-Black tree, the nodes that have no child are considered the internal nodes and these nodes are connected to the NIL nodes that are always black in color. The NIL nodes are the leaf nodes in the Red-Black tree. +
- If the node is Red, then its children should be in Black color. In other words, we can say that there should be no red-red parent-child relationship. +
- Every path from a node to any of its descendant's NIL node should have same number of black nodes. +
- Every AVL tree can be a Red-Black tree if we color each node either by Red or Black color. But every Red-Black tree is not an AVL because the AVL tree is strictly height-balanced while the Red-Black tree is not completely height-balanced. +
+
B Tree#
+B Tree is a specialized m-way tree that can be widely used for disk access. A B-Tree of order m can have at most m-1 keys and m children. One of the main reason of using B tree is its capability to store large number of keys in a single node and large key values by keeping the height of the tree relatively small.
+A B tree of order m contains all the properties of an M way tree. In addition, it contains the following properties:
+-
+
- Every node in a B-Tree contains at most m children. +
- Every node in a B-Tree except the root node and the leaf node contain at least m/2 children. +
- The root nodes must have at least 2 nodes. +
- All leaf nodes must be at the same level. +
Appliations of B Tree
+B tree is used to index the data and provides fast access to the actual data stored on the disks since, the access to value stored in a large database that is stored on a disk is a very time consuming process.
+Searching an un-indexed and unsorted database containing n key values needs O(n) running time in worst case. However, if we use B Tree to index this database, it will be searched in O(log n) time in worst case.
++
B+ Tree#
+B+ Tree is an extension of B Tree which allows efficient insertion, deletion and search operations.
+In B Tree, Keys and records both can be stored in the internal as well as leaf nodes. Whereas, in B+ tree, records (data) can only be stored on the leaf nodes while internal nodes can only store the key values.
+The leaf nodes of a B+ tree are linked together in the form of a singly linked lists to make the search queries more efficient.
+B+ Tree are used to store the large amount of data which can not be stored in the main memory. Due to the fact that, size of main memory is always limited, the internal nodes (keys to access records) of the B+ tree are stored in the main memory whereas, leaf nodes are stored in the secondary memory.
+
Properties of B+ Tree
+-
+
- Every node in a B+ Tree, except root, will hold a maximum of m children and (m-1) keys, and a minimum of [m/2] children and [(m-1)/2] keys, since the order of the tree is m. +
- Height of the tree remains balanced and less as compare to B tree. +
- We can access the data stored in a B+ tree sequentially as well as directly. +
- Keys are used for indexing. + +
Advantages of B+ Tree
+-
+
- Records can be fetched in equal number of disk accesses. +
- The root node must have no less than two children and at least one search key. +
- All the paths in a B tree must end at the same level, i.e. the leaf nodes must be at the same level. +
- A B+ tree always maintains sorted data. +
The operations supported in B+ trees are Insertion, deletion and searching with the time complexity of O(log n) for every operation.
+They are almost similar to the B tree operations as the base idea to store data in both data structures is same. However, the difference occurs as the data is stored only in the leaf nodes of a B+ trees, unlike B trees.
+