1.

Binary Tree

●​ A tree where each node has at most two children (left and right).
●​ Used for various applications, including expression trees and binary heaps.

2. Binary Search Tree (BST)

●​ A binary tree with the property that for each node:

○​ All values in the left subtree are less than the node's value.
○​ All values in the right subtree are greater than the node's value.
●​ Efficient for searching, insertion, and deletion operations.

3. AVL Tree

●​ A self-balancing binary search tree.

●​ Ensures that the heights of the two child subtrees of any node differ by at most one.
●​ Provides O(log n) time complexity for search, insertion, and deletion.

4. Red-Black Tree

●​ A balanced binary search tree with an additional property of color (red or black) for each
node.
●​ Ensures that the tree remains approximately balanced, providing O(log n) time
complexity for operations.

5. B-Tree

●​ A self-balancing tree data structure that maintains sorted data and allows searches,
sequential access, insertions, and deletions in logarithmic time.
●​ Commonly used in databases and file systems.

Key Terminologies Associated with Trees

●​ Node: The fundamental part of a tree that contains data.

●​ Root: The top node of a tree, where the tree starts.
●​ Leaf: A node with no children.
●​ Height: The length of the longest path from the root to a leaf.
●​ Depth: The length of the path from the root to a specific node.
●​ Subtree: A tree formed by a node and its descendants.
Height and Depth of a Tree

●​ Height: The height of a tree is defined as the number of edges on the longest path from
the root to a leaf. For a tree with only one node (the root), the height is 0.
●​ Depth: The depth of a node is the number of edges from the root to that node. The root
node has a depth of 0.

Characteristics of a Binary Tree

●​ Structure: Each node has at most two children, referred to as the left child and the right
child.
●​ Recursive Definition: A binary tree is either empty or consists of a root node and two
subtrees (left and right).
●​ Traversal: Common traversal methods include in-order, pre-order, and post-order.

Threaded Binary Tree vs. Standard Binary Tree

●​ Threaded Binary Tree: In a threaded binary tree, null pointers are replaced with
pointers to the in-order predecessor or successor, making in-order traversal faster
without using a stack or recursion.
●​ Standard Binary Tree: In a standard binary tree, null pointers point to null, and traversal
typically requires additional data structures or recursion.

Definition of a Binary Search Tree (BST)

●​ A Binary Search Tree (BST) is a binary tree where:

○​ The left subtree of a node contains only nodes with values less than the node’s
value.
○​ The right subtree of a node contains only nodes with values greater than the
node’s value.
○​ Both left and right subtrees are also binary search trees.

Balancing Criteria for AVL Trees

●​ An AVL Tree is a self-balancing binary search tree where:

○​ The difference in heights between the left and right subtrees (balance factor) for
any node is at most 1.
 ○​ This ensures that the tree remains balanced, providing O(log n) time complexity
for search, insertion, and deletion operations.

Common Operations Performed on Binary Trees

1.​ Insertion: Adding a new node to the tree.

2.​ Deletion: Removing a node from the tree.
3.​ Traversal: Visiting all the nodes in a specific order (in-order, pre-order, post-order).
4.​ Searching: Finding a node with a specific value.
5.​ Height Calculation: Determining the height of the tree.
6.​ Counting Nodes: Counting the total number of nodes in the tree.

Inserting a Node in a Binary Search Tree (BST)

1.​ Start at the root: Compare the value to be inserted with the root node.
2.​ Go left or right:
○​ If the value is less than the current node's value, move to the left child.
○​ If the value is greater, move to the right child.
3.​ Repeat: Continue this process until you find a null position where the new node can be
inserted.
4.​ Insert the node: Create a new node and attach it to the appropriate null position.

Algorithm for Deleting a Node from an AVL Tree

1.​ Perform standard BST deletion: Locate the node to be deleted and remove it using the
standard BST deletion process.
2.​ Rebalance the tree: After deletion, check the balance factor of each node from the
deleted node's parent up to the root.
3.​ Perform rotations:
○​ If the balance factor is greater than 1, perform a right rotation or left-right rotation.
○​ If the balance factor is less than -1, perform a left rotation or right-left rotation.
4.​ Update heights: After rotations, update the heights of the affected nodes.

Traversing a Binary Tree

1.​ In-Order Traversal (Left, Root, Right):​

○​ Visit the left subtree.

○​ Visit the root node.
 ○​ Visit the right subtree.
○​ This traversal results in nodes being visited in ascending order for BSTs.
2.​ Pre-Order Traversal (Root, Left, Right):​

○​ Visit the root node.

○​ Visit the left subtree.
○​ Visit the right subtree.
○​ This traversal is useful for creating a copy of the tree.
3.​ Post-Order Traversal (Left, Right, Root):​

○​ Visit the left subtree.

○​ Visit the right subtree.
○​ Visit the root node.
○​ This traversal is useful for deleting the tree or evaluating postfix expressions.

Time Complexity of Searching for an Element in a Binary Search Tree

(BST)

●​ Average Case: O(log n)​

○​ In a balanced BST, the height of the tree is logarithmic relative to the number of
nodes, allowing for efficient searching.
●​ Worst Case: O(n)​

○​ In an unbalanced BST (e.g., a tree that resembles a linked list), the height can be
equal to the number of nodes, leading to linear time complexity.

Analyzing the Performance of AVL Tree Operations

1.​ Search Operation:​

○​ Time Complexity: O(log n)

○​ AVL trees maintain balance, ensuring that the height remains logarithmic, which
allows for efficient searching.
2.​ Insertion Operation:​

○​ Time Complexity: O(log n)

○​ Insertion is similar to that in a BST, followed by rebalancing if necessary. The
rebalancing involves at most two rotations, which are constant time operations.
3.​ Deletion Operation:​

○​ Time Complexity: O(log n)

 ○​ Deletion also follows the BST deletion process, followed by rebalancing. Like
insertion, it may require at most two rotations.
4.​ Overall Performance:​

○​ AVL trees provide guaranteed logarithmic time complexity for search, insertion,
and deletion operations due to their self-balancing nature.

Practical Applications of Binary Trees in Computer Science

1.​ Binary Search Trees (BST):​

○​ Used for efficient searching, insertion, and deletion of data.

○​ Commonly implemented in databases and file systems.
2.​ Heaps:​

○​ Binary trees are used to implement binary heaps, which are essential for priority
queues.
○​ Heaps are used in algorithms like heapsort.
3.​ Expression Trees:​

○​ Used to represent expressions in compilers and interpreters.

○​ Facilitate the evaluation of arithmetic expressions.
4.​ Huffman Coding Trees:​

○​ Used in data compression algorithms to create optimal prefix codes.

○​ Helps in reducing the size of data for storage and transmission.
5.​ Decision Trees:​

○​ Used in machine learning for classification and regression tasks.

○​ Helps in making decisions based on feature values.

Binary Trees in Expression Parsing

●​ Expression Trees:​

○​ Binary trees can represent mathematical expressions where each internal node
is an operator (e.g., +, -, *, /) and each leaf node is an operand (e.g., numbers).
●​ Parsing Process:​

○​ When parsing an expression, the expression is converted into a tree structure,

allowing for easy evaluation.
For example, the expression (3 + 5) * 2 can be represented as:​
*

/\

+ 2

/\

3 5

○​
●​ Evaluation:​

○​ To evaluate the expression, a post-order traversal can be used, where the

operands are evaluated first, followed by the operator.

Defining Characteristics of B-Trees

1.​ Balanced: B-trees maintain balance by ensuring that all leaf nodes are at the same
level.
2.​ Multi-way Tree: Each node can have multiple children (more than two), which allows for
a higher branching factor.
3.​ Sorted Order: Keys within each node are stored in sorted order, allowing for efficient
searching.
4.​ Node Capacity: Each node can contain a predefined number of keys (between a
minimum and maximum), which helps in maintaining balance.
5.​ Dynamic Growth: B-trees can grow and shrink dynamically as keys are inserted or
deleted.

Differences Between B-Trees and Binary Search Trees (BST)

1.​ Node Structure:​

○​ B-Trees: Nodes can have multiple keys and children.

○​ BST: Each node has at most two children (left and right).
2.​ Height:​

○​ B-Trees: Generally shallower due to higher branching factors, leading to fewer

disk accesses.
○​ BST: Can become unbalanced, leading to a height equal to the number of nodes
in the worst case.
3.​ Use Cases:​

○​ B-Trees: Commonly used in databases and file systems for efficient disk access.
○​ BST: Used in memory-based applications where data is frequently accessed.

Algorithms for Inserting and Deleting Nodes in a B-Tree

Insertion Algorithm:

1.​ Find the appropriate leaf node: Traverse the tree to find the correct leaf node where
the new key should be inserted.
2.​ Insert the key: If the node has space, insert the key in sorted order.
3.​ Split the node: If the node is full, split it into two nodes and promote the middle key to
the parent node.
4.​ Repeat: If the parent node is also full, repeat the split process up to the root.

Deletion Algorithm:

1.​ Find the key: Traverse the tree to locate the key to be deleted.
2.​ Delete the key:
○​ If the key is in a leaf node, simply remove it.
○​ If the key is in an internal node, replace it with its predecessor or successor and
delete that key.
3.​ Rebalance: If a node has fewer than the minimum number of keys after deletion, borrow
a key from a sibling or merge with a sibling.

Analyzing the Performance of B-Tree Operations

1.​ Search Operation:​

○​ Time Complexity: O(log n)

○​ The height of a B-tree is logarithmic relative to the number of keys, allowing for
efficient searching.
2.​ Insertion Operation:​

○​ Time Complexity: O(log n)

○​ Insertion involves finding the correct leaf node and possibly splitting nodes, both
of which are logarithmic operations.
3.​ Deletion Operation:​

○​ Time Complexity: O(log n)

 ○​ Similar to insertion, deletion involves finding the key and potentially rebalancing
the tree.
4.​ Overall Performance:​

○​ B-trees are optimized for systems that read and write large blocks of data,
making them suitable for databases and file systems.

Key Terminologies Associated with Graphs

1.​ Graph: A collection of vertices (or nodes) and edges (connections between the vertices).
2.​ Vertex (Node): A fundamental unit of a graph, representing an entity.
3.​ Edge: A connection between two vertices, which can be directed or undirected.
4.​ Directed Graph (Digraph): A graph where edges have a direction, indicating a one-way
relationship.
5.​ Undirected Graph: A graph where edges have no direction, indicating a two-way
relationship.
6.​ Degree: The number of edges connected to a vertex. In directed graphs, it can be split
into in-degree (incoming edges) and out-degree (outgoing edges).
7.​ Path: A sequence of edges that connects a sequence of vertices.
8.​ Cycle: A path that starts and ends at the same vertex without repeating any edges.
9.​ Connected Graph: A graph where there is a path between every pair of vertices.
10.​Subgraph: A graph formed from a subset of the vertices and edges of another graph.

Directed and Undirected Graphs

●​ Directed Graph:​

○​ Definition: A graph in which each edge has a direction, represented as an

ordered pair of vertices (u, v), indicating a connection from vertex u to vertex v.
○​ Example: A graph representing a one-way street where traffic can only flow in
one direction.
●​ Undirected Graph:​

○​ Definition: A graph in which edges have no direction, represented as an

unordered pair of vertices {u, v}, indicating a bidirectional connection.
○​ Example: A graph representing a two-way street where traffic can flow in both
directions.

Different Ways to Represent a Graph in Memory

1.​ Adjacency Matrix:​

 ○​ A 2D array where the rows and columns represent vertices.
○​ An entry at position (i, j) indicates the presence (and possibly the weight) of an
edge from vertex i to vertex j.
2.​ Adjacency List:​

○​ An array (or list) of lists where each index represents a vertex.

○​ Each list at index i contains the vertices that are adjacent to vertex i.
3.​ Edge List:​

○​ A list of edges, where each edge is represented as a pair (or tuple) of vertices.
○​ Useful for sparse graphs and simple edge-based operations.
4.​ Incidence Matrix:​

○​ A 2D array where rows represent vertices and columns represent edges.

○​ An entry indicates whether a vertex is incident to an edge.

Differences Between Adjacency Lists and Adjacency Matrices

1.​ Space Complexity:​

○​ Adjacency List: O(V + E), where V is the number of vertices and E is the
number of edges. More space-efficient for sparse graphs.
○​ Adjacency Matrix: O(V^2). Requires space for all possible edges, regardless of
whether they exist.
2.​ Time Complexity for Operations:​

○​ Adjacency List:
■​ Checking for the existence of an edge: O(V) in the worst case (need to
search through the list).
■​ Adding an edge: O(1) (just append to the list).
○​ Adjacency Matrix:
■​ Checking for the existence of an edge: O(1) (direct access).
■​ Adding an edge: O(1) (direct access).
3.​ Use Cases:​

○​ Adjacency List: Preferred for sparse graphs where the number of edges is much
less than the maximum possible (V^2).
○​ Adjacency Matrix: Useful for dense graphs where the number of edges is close
to the maximum possible.

Characteristics of Weighted and Unweighted Graphs

 1.​ Weighted Graph:​

○​ Definition: A graph in which each edge has an associated weight (or cost),
representing a value such as distance, time, or capacity.
○​ Characteristics:
■​ Edges can have positive, negative, or zero weights.
■​ Useful for applications like shortest path algorithms (e.g., Dijkstra's or
Bellman-Ford).
■​ The weight of an edge influences the overall cost of traversing the graph.
2.​ Unweighted Graph:​

○​ Definition: A graph in which edges do not have weights; all edges are
considered equal.
○​ Characteristics:
■​ Typically used in scenarios where the presence of an edge is more
important than the cost of traversing it.
■​ Algorithms like Breadth-First Search (BFS) can be used to find the
shortest path in terms of the number of edges.

Definition of a Complete Graph

●​ Complete Graph:
○​ Definition: A graph in which every pair of distinct vertices is connected by a
unique edge.
○​ Characteristics:
■​ If a complete graph has ( n ) vertices, it contains ( \frac{n(n-1)}{2} ) edges.
■​ Denoted as ( K_n ), where ( n ) is the number of vertices.
■​ Every vertex is directly connected to every other vertex, making it highly
interconnected.

Differences Between Depth-First Search (DFS) and Breadth-First Search (BFS)

1.​ Traversal Method:

○​ DFS: Explores as far as possible along each branch before backtracking. It
goes deep into the graph.
○​ BFS: Explores all neighbors at the present depth prior to moving on to
nodes at the next depth level. It goes wide across the graph.
2.​ Data Structure Used:
○​ DFS: Typically uses a stack (either explicitly or via recursion).
○​ BFS: Uses a queue to keep track of the next vertex to visit.
3.​ Path Finding:
○​ DFS: May not find the shortest path in an unweighted graph.
 ○​ BFS: Guarantees the shortest path in an unweighted graph.
4.​ Space Complexity:
○​ DFS: O(h), where h is the maximum height of the tree (or depth of the
graph).
○​ BFS: O(b^d), where b is the branching factor and d is the depth of the
shallowest solution.
5.​ Use Cases:
○​ DFS: Useful for problems like topological sorting, solving puzzles with a
single solution, and pathfinding in mazes.
○​ BFS: Useful for finding the shortest path, level-order traversal, and in
scenarios where the solution is closer to the root.

Depth-First Search (DFS) in C

1.​ Recursive Implementation:

6.​ #include <stdio.h>
7.​ #include <stdlib.h>
8.​
9.​ #define MAX_VERTICES 100
10.​
11.​void dfs_recursive(int graph[MAX_VERTICES][MAX_VERTICES], int visited[], int vertex,
int num_vertices) {
12.​ visited[vertex] = 1; // Mark the vertex as visited
13.​ printf("%d ", vertex); // Process the vertex
14.​
15.​ for (int i = 0; i < num_vertices; i++) {
16.​ if (graph[vertex][i] == 1 && !visited[i]) { // Check for an edge and if not visited
17.​ dfs_recursive(graph, visited, i, num_vertices);
18.​ }
19.​ }
20.​}
21.​
22.​int main() {
23.​ int graph[MAX_VERTICES][MAX_VERTICES] = {0};
24.​ int visited[MAX_VERTICES] = {0};
25.​ int num_vertices = 6;
26.​
27.​ // Example graph (adjacency matrix)
28.​ graph[0][1] = 1; graph[0][2] = 1; // A -> B, A -> C
29.​ graph[1][3] = 1; graph[1][4] = 1; // B -> D, B -> E
30.​ graph[2][5] = 1; // C -> F
31.​
32.​ printf("DFS Recursive: ");
33.​ dfs_recursive(graph, visited, 0, num_vertices); // Start from vertex 0 (A)
34.​ return 0;
35.​}

2.​ Iterative Implementation:

36.​#include <stdio.h>
37.​#include <stdlib.h>
38.​
39.​#define MAX_VERTICES 100
40.​
41.​void dfs_iterative(int graph[MAX_VERTICES][MAX_VERTICES], int num_vertices, int
start) {
42.​ int visited[MAX_VERTICES] = {0};
43.​ int stack[MAX_VERTICES], top = -1;
44.​
45.​ stack[++top] = start; // Push the start vertex onto the stack
46.​
47.​ while (top != -1) {
48.​ int vertex = stack[top--]; // Pop the top vertex
49.​ if (!visited[vertex]) {
50.​ visited[vertex] = 1; // Mark as visited
51.​ printf("%d ", vertex); // Process the vertex
52.​
53.​ for (int i = num_vertices - 1; i >= 0; i--) { // Push neighbors onto the stack
54.​ if (graph[vertex][i] == 1 && !visited[i]) {
55.​ stack[++top] = i;
56.​ }
57.​ }
58.​ }
59.​ }
60.​}
61.​
62.​int main() {
63.​ int graph[MAX_VERTICES][MAX_VERTICES] = {0};
64.​ int num_vertices = 6;
65.​
66.​ // Example graph (adjacency matrix)
67.​ graph[0][1] = 1; graph[0][2] = 1; // A -> B, A -> C
68.​ graph[1][3] = 1; graph[1][4] = 1; // B -> D, B -> E
69.​ graph[2][5] = 1; // C -> F
70.​
71.​ printf("DFS Iterative: ");
72.​ dfs_iterative(graph, num_vertices, 0); // Start from vertex 0 (A)
73.​ return 0;
74.​}

Breadth-First Search (BFS) in C

75.​#include <stdio.h>
76.​#include <stdlib.h>
77.​
78.​#define MAX_VERTICES 100
79.​
80.​void bfs(int graph[MAX_VERTICES][MAX_VERTICES], int num_vertices, int start) {
81.​ int visited[MAX_VERTICES] = {0};
82.​ int queue[MAX_VERTICES], front = 0, rear = 0;
83.​
84.​ queue[rear++] = start; // Enqueue the start vertex
85.​ visited[start] = 1; // Mark as visited
86.​
87.​ while (front < rear) {
88.​ int vertex = queue[front++]; // Dequeue the front vertex
89.​ printf("%d ", vertex); // Process the vertex
90.​
91.​ for (int i = 0; i < num_vertices; i++) {
92.​ if (graph[vertex][i] == 1 && !visited[i]) { // Check for an edge and if not visited
93.​ queue[rear++] = i; // Enqueue the neighbor
94.​ visited[i] = 1; // Mark as visited
95.​ }
96.​ }
97.​ }
98.​}
99.​
100.​ int main() {
101.​ int graph[MAX_VERTICES][MAX_VERTICES] = {0};
102.​ int num_vertices = 6;
 103.​
104.​ // Example graph (adjacency matrix)
105.​ graph[0][1] = 1; graph[0][2] = 1; // A -> B, A -> C
106.​ graph[1][3] = 1; graph[1][4] = 1; // B -> D, B -> E
107.​ graph[2][5] = 1; // C -> F
108.​
109.​ printf("BFS: ");
110.​ bfs(graph, num_vertices, 0); // Start from vertex 0 (A)
111.​ return 0;
112.​ }

What is Dijkstra's Algorithm, and How Does It Work?

Dijkstra's Algorithm is a popular algorithm used to find the shortest path from a starting node
(or vertex) to all other nodes in a weighted graph with non-negative edge weights.

How It Works:

1.​ Initialization:​

○​ Set the distance to the starting node to 0 and all other nodes to infinity.
○​ Create a priority queue (or min-heap) to store nodes based on their current
shortest distance.
2.​ Processing Nodes:​

○​ While the priority queue is not empty:

■​ Extract the node with the smallest distance (let's call it current).
■​ For each neighbor of current, calculate the distance from the starting
node to that neighbor through current.
■​ If this new distance is less than the previously recorded distance, update
the distance and add the neighbor to the priority queue.
3.​ Termination:​

○​ The algorithm continues until all nodes have been processed, resulting in the
shortest path from the starting node to all other nodes.

How Do You Analyze the Time Complexity of Dijkstra's Algorithm?

The time complexity of Dijkstra's algorithm depends on the data structure used for the priority
queue:
 ●​ Using a simple array: O(V^2), where V is the number of vertices. This is because for
each vertex, you may need to scan through all vertices to find the minimum distance.​

●​ Using a binary heap (priority queue): O((V + E) log V), where E is the number of
edges. This is more efficient because:​

○​ Each vertex is processed once (O(V)).

○​ Each edge is relaxed (checked) once (O(E)).
○​ The log V factor comes from the operations on the priority queue.

What is the Purpose of Warshall's Algorithm in Graph Theory?

Warshall's Algorithm is used to find the transitive closure of a directed graph. It determines
whether there is a path between every pair of vertices in the graph.

Purpose:

●​ Transitive Closure: It creates a matrix that indicates whether a path exists between
pairs of vertices. If there is a path from vertex A to vertex B, the matrix entry will be true
(or 1); otherwise, it will be false (or 0).
●​ Applications: Useful in various applications, such as:
○​ Analyzing reachability in networks.
○​ Finding paths in databases.
○​ Solving problems related to connectivity in graphs.

What Are the Characteristics of a Spanning Tree?

A spanning tree of a graph has the following characteristics:

1.​ Subgraph: It is a subgraph that includes all the vertices of the original graph.
2.​ Connected: The spanning tree is connected, meaning there is a path between any two
vertices.
3.​ Acyclic: It contains no cycles, which means there are no closed loops.
4.​ Edges: For a graph with ( V ) vertices, a spanning tree will have exactly ( V - 1 ) edges.
5.​ Minimum Weight: In the case of a weighted graph, a minimum spanning tree (MST) is a
spanning tree with the minimum possible total edge weight.

How Does Kruskal's Algorithm Work for Finding a Minimum Spanning

Tree?

Kruskal's Algorithm is a greedy algorithm used to find the minimum spanning tree of a
connected, weighted graph. Here’s how it works:

1.​ Sort Edges: Start by sorting all the edges in non-decreasing order of their weights.
 2.​ Initialize: Create a forest (a set of trees), where each vertex is a separate tree. Also,
create a union-find data structure to keep track of connected components.
3.​ Process Edges:
○​ Iterate through the sorted edges and for each edge:
■​ Check if the edge connects two different trees (using the union-find
structure).
■​ If it does, add the edge to the minimum spanning tree and unite the two
trees.
4.​ Termination: The algorithm stops when there are ( V - 1 ) edges in the spanning tree,
where ( V ) is the number of vertices.

What Is Prim's Algorithm, and How Does It Differ from Kruskal's

Algorithm?

Prim's Algorithm is another greedy algorithm used to find the minimum spanning tree of a
connected, weighted graph. Here’s how it works:

1.​ Initialization: Start with a single vertex (arbitrarily chosen) and mark it as part of the
minimum spanning tree.
2.​ Expand Tree:
○​ While there are vertices not yet included in the tree:
■​ Find the edge with the minimum weight that connects a vertex in the tree
to a vertex outside the tree.
■​ Add this edge and the new vertex to the tree.
3.​ Termination: The algorithm continues until all vertices are included in the minimum
spanning tree.

Differences Between Kruskal's and Prim's Algorithms:

●​ Approach:​

○​ Kruskal's Algorithm: Works by sorting edges and adding them one by one,
ensuring no cycles are formed.
○​ Prim's Algorithm: Grows the spanning tree from a starting vertex by adding the
minimum edge that connects the tree to a new vertex.
●​ Data Structure:​

○​ Kruskal's Algorithm: Primarily uses a union-find data structure to manage

connected components.
○​ Prim's Algorithm: Often uses a priority queue to efficiently find the minimum
edge.
●​ Graph Type:​
○​ Kruskal's Algorithm: Can be used on disconnected graphs (it will find a
minimum spanning forest).
○​ Prim's Algorithm: Requires a connected graph to function properly.