Trees
1. Define Tree. Explain the tree traversals with algorithms and examples.
A tree is a hierarchical data structure composed of nodes, where each node stores data and can have child nodes. A
tree is defined by the following properties:
1. There is one root node (topmost node) in the tree.
2. Each node has zero or more child nodes.
3. Nodes are connected by edges, and there are no cycles in a tree structure.
4. Trees are widely used in applications like file systems, hierarchical databases, and AI algorithms
Tree Traversals
Tree traversal refers to the process of visiting all the nodes in a tree in a specific order. Traversals are mainly divided
into Depth-First Traversals (DFT) and Breadth-First Traversals (BFT).
Depth-First Traversal (DFT)
1. Preorder Traversal (NLR): Visit the root, traverse the left subtree, then traverse the right subtree.
2. Inorder Traversal (LNR): Traverse the left subtree, visit the root, then traverse the right subtree.
3. Postorder Traversal (LRN): Traverse the left subtree, traverse the right subtree, then visit the root.
Breadth-First Traversal (BFT)
1. Level Order Traversal: Visit all nodes level by level from top to bottom.
Algorithms
1) Algorithm Preorder Traversal (NLR):
void preorder(Node* root) {
if (root != NULL) {
printf("%d ", root->data); // Visit root
preorder(root->left); // Traverse left subtree
preorder(root->right); // Traverse right subtree
}}
2) Algorithm for Inorder Traversal (LNR):
void inorder(Node* root) {
if (root != NULL) {
inorder(root->left); // Traverse left subtree
printf("%d ", root->data); // Visit root
inorder(root->right); // Traverse right subtree
}}
3) Algorithm for Postorder Traversal (LRN):
void postorder(Node* root) {
if (root != NULL) {
postorder(root->left); // Traverse left subtree
postorder(root->right); // Traverse right subtree
printf("%d ", root->data); // Visit root
}}
4) Algorithm for Level Order Traversal:
void levelOrder(Node* root) {
if (root == NULL) return;
Queue* queue = createQueue(); // Use a queue for BFS
enqueue(queue, root);
while (!isEmpty(queue)) {
Node* current = dequeue(queue);
printf("%d ", current->data);
if (current->left != NULL) enqueue(queue, current->left);
if (current->right != NULL) enqueue(queue, current->right);
}}
Example
Consider the following tree:
1
/ \
2 3
/ \
4 5
Traversals:
1. Preorder (NLR): 1, 2, 4, 5, 3
2. Inorder (LNR): 4, 2, 5, 1, 3
3. Postorder (LRN): 4, 5, 2, 3, 1
4. Level Order: 1, 2, 3, 4, 5
2. Define binary tree and give the binary tree node structure.
A binary tree is a hierarchical data structure in which each node has at most two children, referred to as the left
child and the right child. Binary trees are widely used in searching, sorting algorithms, and in representing
hierarchical data.
Binary Tree Node Structure
In a binary tree, each node consists of:
1. Data: The value or information stored in the node.
2. Left Child: A pointer/reference to the left child node.
3. Right Child: A pointer/reference to the right child node.
Binary Tree Node Structure in C
typedef struct Node {
int data; // Data part of the node
struct Node* left; // Pointer to the left child
struct Node* right; // Pointer to the right child
} Node;
3. What are the different ways of representing a binary tree?
Explain the Linked representation.
1)Array Representation
• The binary tree is stored in a 1D array where:
o The root node is at index 1 (or 0 in zero-based indexing).
o The left child of a node at index i is at 2*i (or 2*i + 1 in zero-based indexing).
o The right child of a node at index i is at 2*i + 1 (or 2*i + 2 in zero-based indexing).
o The parent of a node at index i is at floor(i/2) (or floor((i-1)/2) in zero-based indexing).
Example: Consider the binary tree
1
/ \
2 3
/ \
4 5
Its array representation (1-based indexing): [1, 2, 3, 4, 5].
2)Linked Representation
• Each node is represented as a structure containing:
o Data field.
o Pointer to the left child.
o Pointer to the right child.
typedef struct Node {
int data; // Data stored in the node
struct Node* left; // Pointer to the left child
struct Node* right; // Pointer to the right child
} Node;
4. Explain the terms 'node', 'root', 'parent', 'child', 'leaf', and 'depth'
in the context of trees.
Terms in Trees
• Node: A basic unit of a tree containing data.
• Root: The topmost node in the tree.
• Parent: A node with child nodes.
• Child: A node that has a parent node.
• Leaf: A node without children.
• Depth: The number of edges from the root to the node.
5. Describe the preorder, inorder, and postorder traversal techniques for binary trees. Provide an example tree
and demonstrate each traversal method.
1. Preorder Traversal (NLR)
• Definition: Visit the root node first, then recursively traverse the left subtree, followed by the right subtree.
• Order of Traversal: Node → Left → Right
Algorithm:
1. Visit the root node.
2. Traverse the left subtree in preorder.
3. Traverse the right subtree in preorder.
Example Tree
1
/ \
2 3
/ \
4 5
Steps:
1. Visit 1 (root).
2. Traverse left subtree: 2 → 4, 5.
3. Traverse right subtree: 3.
Output: 1, 2, 4, 5, 3
2. Inorder Traversal (LNR)
• Definition: Recursively traverse the left subtree first, visit the root node, and finally traverse the right
subtree.
• Order of Traversal: Left → Node → Right
Algorithm:
1. Traverse the left subtree in inorder.
2. Visit the root node.
3. Traverse the right subtree in inorder.
Example Tree
1
/ \
2 3
/ \
4 5
Steps:
1. Traverse left subtree: 4, 2, 5.
2. Visit 1 (root).
3. Traverse right subtree: 3.
Output: 4, 2, 5, 1, 3
3. Postorder Traversal (LRN)
• Definition: Recursively traverse the left subtree first, then traverse the right subtree, and finally visit the
root node.
• Order of Traversal: Left → Right → Node
Algorithm:
1. Traverse the left subtree in postorder.
2. Traverse the right subtree in postorder.
3. Visit the root node.
Example Tree
1
/ \
2 3
/ \
4 5
Steps:
1. Traverse left subtree: 4, 5, 2.
2. Traverse right subtree: 3.
3. Visit 1 (root).
Output: 4, 5, 2, 3, 1
6. Define traversal . what are the different types of traversals that
can be performed on a tree?
Traversal is the process of visiting each node in a tree data structure exactly once in a systematic way to perform
some operation (e.g., printing node data, searching for a node). It ensures that all nodes are processed in a structured
manner.
Types of Traversals in a Tree
1. Depth-First Traversal (DFT)
2. Breadth-First Traversal (BFT)
1. Depth-First Traversal (DFT)
• In depth-first traversal, nodes are visited by exploring as far down a branch as possible before backtracking.
• This category includes the following:
o Preorder Traversal (NLR): Visit root → Traverse left subtree → Traverse right subtree.
o Inorder Traversal (LNR): Traverse left subtree → Visit root → Traverse right subtree.
o Postorder Traversal (LRN): Traverse left subtree → Traverse right subtree → Visit root.
Example of DFT Traversal
For the tree:
1
/ \
2 3
/ \
4 5
• Preorder (NLR): 1, 2, 4, 5, 3
• Inorder (LNR): 4, 2, 5, 1, 3
• Postorder (LRN): 4, 5, 2, 3, 1
2. Breadth-First Traversal (BFT)
• In breadth-first traversal, nodes are visited level by level from top to bottom.
• This is also known as Level Order Traversal.
Algorithm:
1. Start at the root.
2. Visit all nodes at the current level before moving to the next level.
Example of BFT Traversal
For the tree:
1
/ \
2 3
/ \
4 5
Level Order: 1, 2, 3, 4, 5
7. Construct a BST from the following elements by repeatedly inserting them into the BST. 8 10 3 6 14 1 7 4 13.
Perform and display the three tree traversals on the above tree.(10 marks)
Step-by-Step Construction
1. Insert 8: Root = 8
2. Insert 10: 10 > 8, goes to the right of 8.
8
\
10
3. Insert 3: 3 < 8, goes to the left of 8.
8
/ \
3 10
4. Insert 6: 6 > 3, goes to the right of 3.
8
/ \
3 10
\
6
5. Insert 14: 14 > 8 and 14 > 10, goes to the right of 10.
8
/ \
3 10
\ \
6 14
6. Insert 1: 1 < 8 and 1 < 3, goes to the left of 3.
8
/ \
3 10
/ \ \
1 6 14
7. Insert 7: 7 < 8, 7 > 3, 7 > 6, goes to the right of 6.
8
/ \
3 10
/ \ \
1 6 14
\
7
8. Insert 4: 4 < 8, 4 > 3, 4 < 6, goes to the left of 6.
8
/ \
3 10
/ \ \
1 6 14
/ \
4 7
9. Insert 13: 13 > 8, 13 > 10, 13 < 14, goes to the left of 14.
8
/ \
3 10
/ \ \
1 6 14
/ \ /
4 7 13
Final BST
8
/ \
3 10
/ \ \
1 6 14
/ \ /
4 7 13
Traversal Results
1. Preorder Traversal (NLR):
Visit root → Traverse left subtree → Traverse right subtree.
Order: 8, 3, 1, 6, 4, 7, 10, 14, 13
2. Inorder Traversal (LNR):
Traverse left subtree → Visit root → Traverse right subtree.
Order: 1, 3, 4, 6, 7, 8, 10, 13, 14
3. Postorder Traversal (LRN):
Traverse left subtree → Traverse right subtree → Visit root.
Order: 1, 4, 7, 6, 3, 13, 14, 10, 8
8. Write a C function to insert an element into a BST. (5 marks)
Node* insert(Node* root, int data) {
if (root == NULL) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
if (data < root->data) root->left = insert(root->left, data);
else root->right = insert(root->right, data);
return root;
}
9. Write a C function to delete an element from the BST. Describe
with an example for each of the three cases that can arise while
deleting an element from BST. (10 marks)
#include <stdio.h>
#include <stdlib.h>
// Define the structure for a node in BST
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to delete a node from BST
Node* deleteNode(Node* root, int data) {
if (root == NULL) return root; // Tree is empty
// Traverse to find the node to delete
if (data < root->data) {
root->left = deleteNode(root->left, data);
} else if (data > root->data) {
root->right = deleteNode(root->right, data);
} else {
// Node to be deleted found
// Case 1: Node has no children (leaf node)
if (root->left == NULL && root->right == NULL) {
free(root);
return NULL;
// Case 2: Node has one child
if (root->left == NULL) {
Node* temp = root->right;
free(root);
return temp;
} else if (root->right == NULL) {
Node* temp = root->left;
free(root);
return temp;
// Case 3: Node has two children
Node* temp = findMin(root->right); // Find inorder successor
root->data = temp->data; // Replace with successor's value
root->right = deleteNode(root->right, temp->data); // Delete successor
return root;
// Main function to demonstrate deletion
int main() {
Node* root = NULL;
// Delete a node
printf("Deleting 1 (leaf node)...\n");
root = deleteNode(root, 1);
printf("Inorder Traversal after deletion: ");
inorder(root);
printf("\n");
printf("Deleting 6 (node with one child)...\n");
root = deleteNode(root, 6);
printf("Inorder Traversal after deletion: ");
inorder(root);
printf("\n");
printf("Deleting 8 (node with two children)...\n");
root = deleteNode(root, 8);
printf("Inorder Traversal after deletion: ");
inorder(root);
printf("\n");
return 0;
}
Three Cases of Deletion
1. Case 1: The node to be deleted is a leaf node (no children)
o Simply remove the node from the tree.
2. Case 2: The node to be deleted has one child (left or right)
o Replace the node with its child.
3. Case 3: The node to be deleted has two children
o Find the inorder successor (smallest node in the right subtree) or the inorder predecessor (largest
node in the left subtree).
o Replace the node's value with the inorder successor or predecessor, and recursively delete the
successor/predecessor.
10. Write C functions to perform any two tree traversals on a Binary Search Tree. (5 marks)
Refer 1st question
11. Define Complete Binary Tree with a example (2 marks)
A Complete Binary Tree is a binary tree in which:
1. All levels except possibly the last are completely filled.
2. All nodes in the last level are as far left as possible
Example
Consider the following tree:
1
/ \
2 3
/ \ /
4 5 6
• This is a Complete Binary Tree because:
1. All levels except the last are completely filled.
2. Nodes in the last level (4, 5, 6) are as far left as possible.
12. Define Almost Complete Binary Tree with a example (2marks)
Almost Complete Binary Tree
An Almost Complete Binary Tree is a binary tree in which:
1. Every node has either 0, 1, or 2 children.
2. All leaf nodes are at the same level or one level above the other leaf nodes.
3. The nodes are filled from the leftmost position, maintaining the shape as close to a Complete Binary Tree as
possible.
Example: Consider the following tree:
1
/ \
2 3
/ \
4 5
• This is an Almost Complete Binary Tree because:
1. The nodes are filled from the leftmost positions.
2. Leaf nodes (4 and 5) are at the same level.
13. Define Balanced Binary Tree with a example (2 marks)
Balanced Binary Tree
A Balanced Binary Tree is a binary tree in which the height difference between the left and right subtrees of every
node is at most 1. This ensures the tree remains balanced, optimizing search, insertion, and deletion operations.
Example
Consider the following tree:
1
/ \
2 3
/ \
4 5
• This is a Balanced Binary Tree because:
1. The height of the left subtree (rooted at 2) is 2.
2. The height of the right subtree (rooted at 3) is 1.
3. The height difference for the root node 1 is |2 - 1| = 1, which is ≤ 1.
14. Define Strictly Binary Tree with a example (2 marks)
A Strictly Binary Tree is a binary tree in which every non-leaf node has exactly two children. This means that each
internal node has either two children or is a leaf node.
Example
Consider the following tree:
1
/ \
2 3
/ \
4 5
• This is a Strictly Binary Tree because:
1. Every non-leaf node (1, 2) has exactly two children.
2. The leaf nodes are 3, 4, and 5.
15. Define the following terms (2 marks)
a) Descendant b)Ancestor
a) Descendant:
A node XXX is a descendant of another node YYY if XXX lies in the subtree rooted at YYY. This includes all nodes
reachable from YYY by following child pointers downward.
• Example: In a tree with root AAA, if BBB is a child of AAA and CCC is a child of BBB, then CCC is a descendant
of both BBB and AAA.
b) Ancestor:
A node XXX is an ancestor of another node YYY if YYY lies in the subtree rooted at XXX. This includes all nodes
reachable from YYY by following parent pointers upward.
• Example: In the same tree, AAA is an ancestor of both BBB and CCC.
For the following tree:
A
/ \
B C
/ \
D E
• Descendants of BBB: D,ED, ED,E.
• Ancestors of EEE: B,AB, AB,A
