MR NOTES HUB

Choice Based Credit

Subject COMPUTER APPLICATION DATA

STRUCTURE

System
Semester: 5 th Session: 2023

Compiled By: ROHAAN SIR

STANDARD NOTES AVAILABLE FOR ALL CLASSES

Book Shop Cum Note House

College Road SUMBAL

Notes Available for 8th, 9th, 10th, 11th, 12th, B.A, B.SC, I, II, III year, M.A, B. Ed, M.
Ed Manuu & Ignou classes and much more #63
9103030057
 MK 5TH Semester

Unit-1: Linear Data Types-1

Q.Introduction to data structure (Linear, Non-Linear, Primitive, Non-
Primitive), Data Structure and Data Operations, Algorithm Complexity
Ans.Introduction to Data Structures

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 2
MMM
 MK 5TH Semester

Data structures are essential components in computer science that organize

and store data efficiently. They provide a means to manage vast amounts of
information, allowing for effective access and modification. Understanding
data structures is crucial for designing algorithms that optimize
performance, as they dictate how data can be processed and manipulated.
Data structures can be categorized into linear and non-linear structures, as
well as primitive and non-primitive types.

Linear Data Structures

Linear data structures organize data in a sequential manner, where each

element is connected to its previous and next element. Common examples of
linear data structures include arrays, linked lists, stacks, and queues. Arrays
are a collection of elements stored in contiguous memory locations, allowing
for fast access via index-based retrieval. Linked lists consist of nodes that
contain data and a reference (or pointer) to the next node, enabling dynamic
memory allocation and efficient insertion and deletion operations.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 3
MMM
 MK 5TH Semester

Non-Linear Data Structures

Non-linear data structures, on the other hand, do not organize data

sequentially. Instead, they allow for more complex relationships among data
elements. Trees and graphs are prime examples of non-linear data
structures. In a tree structure, data is organized hierarchically with a root
node and child nodes, allowing for efficient searching and sorting
operations. Graphs consist of nodes (or vertices) connected by edges,
representing relationships between different entities, which is particularly
useful in network analysis and pathfinding algorithms.

Primitive Data Structures

Primitive data structures are the most basic types of data structures provided
by programming languages. They include data types such as integers, floats,
characters, and booleans. These structures serve as the building blocks for
more complex data structures. For example, integers can be combined into
arrays, and characters can form strings. Primitive data structures are
crucial for performing fundamental operations and serve as the foundation
for algorithm development.

Non-Primitive Data Structures

Non-primitive data structures are built using primitive data types and can be
classified into linear and non-linear structures. Examples include arrays,
linked lists, stacks, queues, trees, and graphs. These structures enable the
organization of complex data types and relationships. Non-primitive data

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 4
MMM
 MK 5TH Semester

structures are essential for implementing algorithms that require more than
simple data manipulation, such as sorting and searching operations.

Data Structure Operations

Data structures support various operations that facilitate the manipulation

and retrieval of data. Common operations include insertion, deletion,
traversal, searching, and sorting. Insertion refers to adding a new element to
the data structure, while deletion involves removing an existing element.
Traversal is the process of visiting each element in a data structure, allowing
for operations such as displaying or modifying data. Searching enables
finding a specific element, and sorting organizes the data in a particular
order.

Algorithm Complexity

Understanding algorithm complexity is vital in evaluating the efficiency of

algorithms associated with data structures. Algorithm complexity is often
expressed in terms of time and space complexity. Time complexity measures
the amount of time an algorithm takes to complete based on the size of the
input data. It is typically represented using Big O notation, which classifies
algorithms according to their worst-case or average-case performance (e.g.,
O(1), O(n), O(log n), O(n²)). Space complexity, on the other hand, assesses
the amount of memory an algorithm requires relative to the input size.

Analyzing Algorithm Performance

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 5
MMM
 MK 5TH Semester

Analyzing algorithm performance helps in selecting the most efficient data

structure for a particular application. Factors such as the frequency of
operations (insertion, deletion, searching) and the type of data being
processed influence this decision. For example, a hash table may be
preferred for fast lookups, while a binary search tree could be more suitable
for ordered data and efficient searching. Understanding the trade-offs
between different data structures and their associated algorithms is crucial
for optimizing performance in software development.

Conclusion

In conclusion, data structures are fundamental to computer science and

programming, enabling the organization, storage, and manipulation of data.
They can be categorized into linear and non-linear, as well as primitive and
non-primitive structures, each serving specific purposes and use cases. The
operations associated with data structures and the analysis of algorithm
complexity play significant roles in optimizing performance and ensuring
efficient data handling. Mastering these concepts equips developers with the
tools necessary for effective algorithm design and implementation.

Q.Single dimensional array and its operations (Searching, traversing,

inserting, deleting), Two-Dimensional array, Addressing, Sparse Matrices,
recursion

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 6
MMM
 MK 5TH Semester

Ans.Single Dimensional Arrays

A single-dimensional array, also known as a one-dimensional array, is a

data structure that stores a fixed-size sequence of elements of the same data
type. It allows for efficient storage and retrieval of data, making it a
fundamental structure in programming. Each element in the array can be
accessed using an index, with the first element typically starting at index
zero.

Operations on Single Dimensional Arrays

1. Searching: Searching in an array involves finding the position of a

specific element. The two common search algorithms are:

Linear Search: This algorithm checks each element sequentially until the
desired element is found or the end of the array is reached. It has a time
complexity of O(n).

Binary Search: This algorithm is more efficient but requires the array to be
sorted. It divides the search interval in half repeatedly, resulting in a time
complexity of O(log n).

2. Traversing: Traversing an array means visiting each element

systematically. This operation typically uses a loop (for, while, etc.) to
access and process each element in the array. For example, to print all

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 7
MMM
 MK 5TH Semester

elements, a for loop iterates from the first to the last index, accessing each
element.
3. Inserting: Inserting an element into an array involves placing a new
element at a specified index, which may require shifting subsequent elements
to maintain order:
If the array is not full, you can insert an element by specifying its index,
shifting elements as necessary.
Inserting at the end of the array is straightforward if there is available
space, while inserting at the beginning or in the middle requires more effort
and has a time complexity of O(n).

4. Deleting: Deleting an element involves removing it from a specified index

and shifting the subsequent elements to fill the gap:

Once the target element is identified, all elements after it are shifted left,
effectively removing the element.
Like insertion, the time complexity for deletion is also O(n) due to the
potential need to shift elements.

Two-Dimensional Arrays

A two-dimensional array, or matrix, is an array of arrays, organized in rows

and columns. It can be visualized as a table where data is accessed using
two indices: one for the row and another for the column. For example, an
array A with m rows and n columns is accessed as A[i][j], where i

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 8
MMM
 MK 5TH Semester

represents the row index and j represents the column index. Two-
dimensional arrays are widely used in applications like image processing,
scientific simulations, and game development.

Addressing in Two-Dimensional Arrays

Addressing in two-dimensional arrays refers to how the elements are stored

in memory. There are two common methods of addressing:

1. Row-Major Order: In this method, the entire row is stored in contiguous

memory locations before moving to the next row. For example, if an array
has m rows and n columns, the address of the element at A[i][j] can be
calculated as:
\text{Address}(A[i][j]) = \text{Base Address} + (i \times n + j) \times \
text{size of element}
2. Column-Major Order: In this method, the entire column is stored in
contiguous memory locations before moving to the next column. The address
can be calculated as:

\text{Address}(A[i][j]) = \text{Base Address} + (j \times m + i) \times \

text{size of element}

Sparse Matrices

A sparse matrix is a two-dimensional array in which most of the elements

are zero. To efficiently store and manipulate sparse matrices, specialized

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 9
MMM
 MK 5TH Semester

data structures are often used to minimize memory usage. Common

representations include:
1. Compressed Sparse Row (CSR): This format stores non-zero values in a
one-dimensional array, along with two additional arrays to record the
column indices of those values and the cumulative count of non-zero
values in each row.

2. Coordinate List (COO): This representation uses three one-dimensional

arrays to store the row indices, column indices, and values of the non-zero
elements, providing a simple way to construct and iterate through sparse
matrices.

Recursion

Recursion is a programming technique where a function calls itself to solve a

smaller instance of the same problem. It consists of a base case, which stops
the recursion, and a recursive case, which continues to break down the
problem. Recursion is often used for tasks that can be defined in terms of
smaller subproblems, such as searching and sorting algorithms (like
quicksort and mergesort), calculating factorials, and traversing complex
data structures like trees.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 10
MMM
 MK 5TH Semester

Example of Recursion

A classic example of recursion is calculating the factorial of a number :

def factorial(n):
if n == 0: # Base case
return 1
else: # Recursive case
return n * factorial(n - 1)

In this example, the function continues to call itself with a decremented value
of until it reaches the base case of zero, at which point it returns 1.

Conclusion

In summary, understanding single-dimensional and two-dimensional arrays,

along with their operations, is crucial for effective data management in
programming. Searching, traversing, inserting, and deleting are
fundamental operations in single-dimensional arrays, while two-dimensional
arrays facilitate more complex data organization, with various addressing
methods and representations for sparse matrices. Additionally, recursion is a
powerful technique that enhances algorithm efficiency by breaking down
problems into smaller, manageable subproblems. Mastering these concepts

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 11
MMM
 MK 5TH Semester

is essential for developing robust algorithms and data processing

applications.
Q.Searching Algorithms: Linear Search, Binary Search and their
Comparison
Ans.Searching Algorithms

Searching algorithms are fundamental techniques in computer science used

to find a specific element within a data structure, such as an array or a list.
The two most commonly used searching algorithms are Linear Search and
Binary Search. Each algorithm has its own characteristics, advantages, and
limitations, which make them suitable for different scenarios.

Linear Search

Linear Search is the simplest searching algorithm. It operates on both sorted

and unsorted arrays and works by sequentially checking each element in the
list until the desired element is found or the end of the list is reached.

Algorithm Steps:

1. Start at the beginning of the array.

2. Compare each element with the target value.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 12
MMM
 MK 5TH Semester

3. If a match is found, return the index of the element.

4. If the end of the array is reached without finding the target, return -1
(indicating that the element is not present).

Time Complexity:

Best Case: O(1) (when the target element is the first element)

Average Case: O(n) (where n is the number of elements)

Worst Case: O(n) (when the target element is at the end or not present)
Space Complexity: O(1) (only a few variables are used)

Advantages:

Simple to implement.
Does not require the array to be sorted.
Disadvantages:
Inefficient for large datasets due to its linear time complexity.

Binary Search

Binary Search is a more efficient searching algorithm, but it requires the

array to be sorted beforehand. It works by repeatedly dividing the search
interval in half.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 13
MMM
 MK 5TH Semester

Algorithm Steps:

1. Start with two pointers, one at the beginning (low) and one at the end
(high) of the sorted array.
2. Calculate the middle index: mid = (low + high) / 2.
3. Compare the middle element with the target value:

If the middle element is equal to the target, return the index.

If the target is less than the middle element, narrow the search to the lower
half by setting high = mid - 1.

If the target is greater than the middle element, narrow the search to the
upper half by setting low = mid + 1.

4. Repeat steps 2-3 until the target is found or the search interval is empty.
Time Complexity:
Best Case: O(1) (when the target is the middle element)
Average Case: O(log n) (where n is the number of elements)
Worst Case: O(log n) (when the search interval is reduced to one element)
Space Complexity: O(1) for the iterative version and O(log n) for the
recursive version due to the call stack.
Advantages:

Much faster than linear search for large datasets.

Efficient use of comparisons.

Disadvantages:

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 14
MMM
 MK 5TH Semester

Requires the array to be sorted, which may involve additional time and
space for sorting.
Comparison of Linear Search and Binary Search

Conclusion

In conclusion, both linear search and binary search are essential algorithms
for locating elements in data structures. Linear search is simple and works
on unsorted data, making it useful for smaller datasets. In contrast, binary
search is much more efficient for larger, sorted datasets but requires an
initial sorting step. Choosing the appropriate algorithm depends on the
context, size of the dataset, and whether the data is sorted. Understanding
these algorithms is fundamental for optimizing search operations in software
development and data processing tasks.
Unit-II: Linear Data Types - II
Q.Array Sorting Algorithms: Selection sort. Insertion sort, Bubble Sort,
Quick sort.Stack: Definition & Concepts
Ans.Array Sorting Algorithms

Sorting algorithms are fundamental techniques used in computer science to

arrange the elements of an array or list in a specific order, typically
ascending or descending. Various algorithms can achieve sorting, each with
unique methodologies, time complexities, and use cases. Here, we will
discuss four common sorting algorithms: Selection Sort, Insertion Sort,
Bubble Sort, and Quick Sort.

Selection Sort

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 15
MMM
 MK 5TH Semester

Selection Sort is a straightforward comparison-based sorting algorithm. The

basic idea behind this algorithm is to divide the array into two parts: the
sorted part and the unsorted part. The sorted part builds up from the left,
while the unsorted part shrinks from the right.

Algorithm Steps:

1. Start with the first element of the array. Assume it is the minimum.

2. Compare this minimum with the other elements in the array.

3. If a smaller element is found, update the minimum.
4. After completing the comparisons, swap the minimum element with the
first element of the unsorted part.
5. Move to the next element and repeat steps 1-4 until the entire array is
sorted.
Time Complexity:
Best Case: O(n^2)
Average Case: O(n^2)
Worst Case: O(n^2)
Space Complexity: O(1) (in-place sorting)
Advantages:
Simple to implement.
Performs well on small datasets.
Requires no additional storage (in-place).
Disadvantages:

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 16
MMM
 MK 5TH Semester

Inefficient for large datasets due to its quadratic time complexity.

It makes O(n^2) comparisons and O(n) swaps.
Insertion Sort
Insertion Sort is another simple sorting algorithm that builds the final sorted
array one element at a time. It works similarly to how people sort playing
cards.

Algorithm Steps:

1. Start from the second element (the first element is considered sorted).
2. Compare the current element with the previous elements.
3. Shift all larger elements one position to the right.
4. Insert the current element into its correct position.
5. Repeat steps 2-4 for all elements in the array until the entire array is
sorted.
Time Complexity:

Best Case: O(n) (when the array is already sorted)

Average Case: O(n^2)
Worst Case: O(n^2)
Space Complexity: O(1) (in-place sorting)
Advantages:
Efficient for small datasets or nearly sorted data.
Stable sort (maintains the relative order of equal elements).

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 17
MMM
 MK 5TH Semester

Simple to implement.
Disadvantages:
Inefficient for large datasets due to its quadratic time complexity.
Bubble Sort
Bubble Sort is a simple comparison-based sorting algorithm that repeatedly
steps through the list, compares adjacent elements, and swaps them if they
are in the wrong order.
Algorithm Steps:

1. Start from the beginning of the array.

2. Compare the first two elements.
3. If the first element is greater than the second, swap them.
4. Move to the next pair of adjacent elements and repeat step 3.
5. Continue this process for the entire array.
6. After each pass, the largest unsorted element "bubbles up" to its correct
position
7. Repeat the process until no swaps are needed, indicating the array is
sorted.
Time Complexity:
Best Case: O(n) (when the array is already sorted)
Average Case: O(n^2)
Worst Case: O(n^2)
Space Complexity: O(1) (in-place sorting)
Advantages:
Simple to implement and understand.
Performs well on small datasets.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 18
MMM
 MK 5TH Semester

Disadvantages:

Inefficient on larger datasets, particularly those that are randomly ordered.

Generally considered one of the least efficient sorting algorithms.

Quick Sort

Quick Sort is a highly efficient sorting algorithm that uses a divide-and-

conquer strategy to sort elements. It is significantly faster than the previously
mentioned algorithms, especially for large datasets.

Algorithm Steps:

1. Choose a "pivot" element from the array. Various methods can be used to
select the pivot, such as the first element, the last element, or the median.
2. Partition the array into two halves: elements less than the pivot and
elements greater than the pivot.
3. Recursively apply the above steps to the sub-arrays of elements less than
and greater than the pivot.
4. Combine the sorted sub-arrays and the pivot to form the final sorted
array.

Time Complexity:
Best Case: O(n log n) (when the pivot divides the array into two equal
halves)

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 19
MMM
 MK 5TH Semester

Average Case: O(n log n)

Worst Case: O(n^2) (when the smallest or largest element is consistently
chosen as the pivot)
Space Complexity: O(log n) (due to the recursive stack)
Advantages:

Generally faster and more efficient for large datasets compared to other
algorithms.
In-place sorting with low memory usage.
Disadvantages:
The worst-case performance can be poor if not implemented correctly.
Not stable (equal elements may not maintain their relative order).
Summary of Sorting Algorithms
Sorting algorithms serve crucial roles in computer science, allowing for the
organization of data for more efficient searching and processing. While
Selection Sort, Insertion Sort, and Bubble Sort are easy to understand and
implement, they may not be suitable for large datasets due to their quadratic
time complexity. Quick Sort, on the other hand, provides a more efficient
alternative for larger arrays through its divide-and-conquer strategy.
Understanding these sorting algorithms, their complexities, and their best-
use cases is essential for anyone working with data in programming or
software development.

Stack: Definition & Concepts

A stack is a linear data structure that follows the Last In, First Out (LIFO)
principle. This means that the last element added to the stack will be the first

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 20
MMM
 MK 5TH Semester

one to be removed. Stacks are commonly used in various programming and

computational scenarios, including function call management, expression
evaluation, and backtracking algorithms.

Basic Operations of a Stack

Stacks typically support a set of standard operations:

1. Push: Adds an element to the top of the stack. This operation increases the
stack size by one.
2. Pop: Removes the top element from the stack. If the stack is empty, this
operation may result in an error (underflow).

3. Peek (or Top): Retrieves the value of the top element without removing it
from the stack. This operation allows the user to inspect the top element.
4. IsEmpty: Checks whether the stack is empty. This operation returns true if
there are no elements in the stack and false otherwise.
5. Size: Returns the number of elements currently in the stack.
Implementation of a Stack
Stacks can be implemented in two primary ways:
1. Array-based Implementation:
This method uses a fixed-size array to store the stack elements.
A variable tracks the index of the top element.
When the stack is full, attempting to push another element results in an
overflow error.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 21
MMM
 MK 5TH Semester

2. Linked List Implementation:

This method uses a linked list where each node contains the stack element
and a reference to the next node.

The top of the stack corresponds to the head of the linked list, allowing for
dynamic resizing without overflow.
Applications of Stacks

Stacks are used in various applications, including:

1. Function Call Management: Stacks are utilized to keep track of function

calls in programming languages. When a function is called, its context is
pushed onto the stack, and when it returns, that context is popped off.

2. Expression Evaluation: In mathematical expressions, stacks can be used

to evaluate postfix (Reverse Polish Notation) or infix expressions. The stack
helps manage operators and operands during the evaluation process
3. Backtracking Algorithms: Stacks are essential in algorithms that explore
all possible solutions, such as maze-solving and puzzle-solving algorithms,
allowing the program to backtrack when it encounters dead ends
4. Memory Management: Stacks help manage memory in programming,
particularly in allocating and deallocating function contexts, thus preventing
memory leaks.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 22
MMM
 MK 5TH Semester

5. Browser History Management: Stacks can be used to manage the back

and forward navigation in web browsers, allowing users to move back to
previously visited pages.
Conclusion

In conclusion, sorting algorithms like Selection Sort, Insertion Sort, Bubble

Sort, and Quick Sort are essential for organizing data efficiently. While each
has its advantages and disadvantages, Quick Sort generally provides the best
performance for larger datasets. On the other hand, stacks are a critical
data structure that facilitates efficient management of elements in a Last In,
First Out manner. Understanding both sorting algorithms and stack concepts
is fundamental for anyone studying computer science, programming, and
data structure principles.
Q.Array Representation of Stack, Operations on Stack. Applications of
Stack: Expressions and their representation: Infix, Prefix, Postfix and
their conversions & evaluation
Ans.Array Representation of Stack

Stacks can be represented in various ways, with one of the most common
being the array representation. This method utilizes a fixed-size array to
store stack elements, where a variable indicates the index of the top element
in the stack.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 23
MMM
 MK 5TH Semester

Structure of Array-Based Stack

1. Array: A one-dimensional array is created to hold the elements of the

stack.
2. Top Variable: An integer variable, often called top, keeps track of the
index of the last inserted element. Initially, it is set to -1, indicating that the
stack is empty.
Basic Operations of Array-Based Stack
The primary operations performed on an array-based stack include:
1. Push:
When an element is pushed onto the stack, the top variable is incremented,
and the element is stored in the array at that index.
Before pushing, a check is performed to ensure the stack is not full (i.e., top
< max_size - 1).

Example:

def push(stack, top, element):

if top < max_size - 1:
top += 1
stack[top] = element
else:
print("Stack Overflow")

2. Pop:

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 24
MMM
 MK 5TH Semester

When an element is popped from the stack, the element at the index indicated
by top is returned, and top is decremented.
A check is performed to ensure the stack is not empty (i.e., top >= 0).
Example:
def pop(stack, top):
if top >= 0:
element = stack[top]
top -= 1
return element
else:
print("Stack Underflow")

3. Peek:

This operation retrieves the top element without modifying the stack. It
checks if the stack is empty before accessing the element.
Example:

def peek(stack, top):

if top >= 0:
return stack[top]
else:
return "Stack is empty"

4. IsEmpty:
This function checks if the stack is empty by returning true if top is -1.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 25
MMM
 MK 5TH Semester

Example:

def is_empty(top):
return top == -1
5. Size:
This function returns the current size of the stack by adding one to top.
Example:
def size(top):
return top + 1
Applications of Stack

Stacks have various applications in computer science, particularly in

expression processing, memory management, and backtracking algorithms.
Here, we will explore the application of stacks in the context of expressions
and their representations: Infix, Prefix, and Postfix notation, along with their
conversions and evaluation.

Expressions and Their Representation

1. Infix Notation:

In infix notation, operators are placed between operands (e.g., A + B).

Parentheses are often used to dictate the order of operations (e.g., A + (B *

C)).

This representation is commonly used in mathematical expressions, but it

can be ambiguous due to varying operator precedence.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 26
MMM
 MK 5TH Semester

2. Prefix Notation (Polish Notation):

In prefix notation, operators precede their operands (e.g., + A B).

This form eliminates ambiguity in operator precedence, making it easier for

computers to evaluate expressions.

Parentheses are not needed to enforce order because the operator's position
indicates the order of evaluation.
3. Postfix Notation (Reverse Polish Notation):

In postfix notation, operators follow their operands (e.g., A B +).

Like prefix notation, postfix notation avoids ambiguity and eliminates the
need for parentheses.

This representation is often easier to evaluate using a stack.

Conversions Between Notations

Infix to Prefix Conversion
To convert an infix expression to prefix notation, follow these steps:
1. Reverse the infix expression.
2. Change parentheses: convert ( to ) and vice versa.
3. Obtain the postfix expression of the modified expression using a stack.
4. Reverse the postfix expression to get the final prefix expression.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 27
MMM
 MK 5TH Semester

Example: For the infix expression A + B * C, the steps are:

Reverse: C * B + A

Change parentheses: C * B + A remains the same as there are no

parentheses.
Convert to postfix: C B * A +
Reverse to get prefix: + A * B C.
Infix to Postfix Conversion
To convert an infix expression to postfix notation, follow these steps:
1. Initialize an empty stack for operators and an output list for the result.
2. Scan the infix expression from left to right.
3. If the token is an operand, add it to the output.

4. If the token is an operator, pop operators from the stack to the output until
the top of the stack has an operator of less precedence or the stack is empty.
Then push the current operator onto the stack.

5. If the token is a left parenthesis (, push it onto the stack.

6. If the token is a right parenthesis ), pop from the stack to the output until a
left parenthesis is at the top of the stack. Remove the left parenthesis from
the stack.
7. After scanning the expression, pop any remaining operators from the stack
to the output.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 28
MMM
 MK 5TH Semester

Example: For the infix expression A + B * C, the steps are:

Scan: A → output: A
Scan: + → stack: +
Scan: B → output: AB
Scan: * → stack: + *
Scan: C → output: ABC
Pop remaining operators: output: ABC*+.
Evaluation of Expressions

Stacks are essential for evaluating postfix and prefix expressions due to their
sequential nature.

Evaluating Postfix Expressions

To evaluate a postfix expression:

1. Initialize an empty stack.

2. Scan the postfix expression from left to right.
3. If the token is an operand, push it onto the stack.
4. If the token is an operator, pop the top two operands from the stack,
apply the operator, and push the result back onto the stack.
5. After the expression is fully scanned, the final result will be at the top of
the stack.

Example: For the postfix expression AB+C*, the steps are:

Push A → Stack: A

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 29
MMM
 MK 5TH Semester

Push B → Stack: A, B
Operator + → Pop A and B, calculate A + B, push result back.
Push C → Stack: A+B, C
Operator * → Pop A+B and C, calculate (A + B) * C.

Evaluating Prefix Expressions

To evaluate a prefix expression:
1. Reverse the prefix expression.

2. Initialize an empty stack.

3. Scan the reversed expression from left to right.

4. If the token is an operand, push it onto the stack.

5. If the token is an operator, pop the top two operands from the stack, apply
the operator, and push the result back onto the stack.
6. After scanning, the final result will be at the top of the stack.
Example: For the prefix expression *+ABC, the steps are:
Reverse: C B A + *
Push C → Stack: C
Push B → Stack: C, B
Push A → Stack: C, B, A
Operator + → Pop A and B, calculate B + A, push result back.

Operator * → Pop result and C, calculate (B + A) * C.

Summary

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 30
MMM
 MK 5TH Semester

The array representation of stacks provides a simple yet effective way to

implement the stack data structure. The various operations—push, pop, peek,
isEmpty, and size—allow for efficient management of data in a Last In, First
Out manner. Stacks play a vital role in expression processing, particularly in
the representation and evaluation of infix, prefix, and postfix notations. By
understanding these representations and conversions, one can effectively
leverage stacks in various computational problems, such as expression
evaluation, memory management, and more. As such, mastering stacks is
fundamental for anyone involved in programming and computer science.
Q.Queue: Definition & Concepts, Array Representation of Queue,
Operations on Queue, Circular Queue, Applications of Queue
Ans.Queue: Definition & Concepts
A queue is a linear data structure that follows the First In, First Out (FIFO)
principle, meaning the first element added to the queue will be the first one
to be removed. This data structure is analogous to a line of people waiting
for a service: the person who arrives first gets served first. Queues are
widely used in various applications, such as scheduling processes in
operating systems, managing requests in web servers, and handling
asynchronous data transfers.

Basic Characteristics of a Queue

1. FIFO Order: The fundamental characteristic of a queue is its FIFO order.

The first element added to the queue will be the first one to be removed. This
property distinguishes queues from stacks, which follow the Last In, First
Out (LIFO) principle.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 31
MMM
 MK 5TH Semester

2. Operations: The basic operations of a queue include:

Enqueue: Adding an element to the back of the queue.
Dequeue: Removing an element from the front of the queue.
Peek (or Front): Viewing the front element of the queue without removing it.
IsEmpty: Checking whether the queue is empty.

Size: Returning the number of elements currently in the queue.

Array Representation of Queue

Queues can be implemented using arrays. In an array-based implementation,
a fixed-size array is created to hold the queue elements. Two pointers or
indices are typically maintained: one for the front of the queue and another
for the rear.

Structure of Array-Based Queue

1. Array: A one-dimensional array is allocated to store the queue elements.

2. Front Pointer: An integer variable, front, indicates the index of the first
element in the queue.
3. Rear Pointer: Another integer variable, rear, indicates the index where
the next element will be added.
Operations on Array-Based Queue
The primary operations on an array-based queue include:
1. Enqueue:

To add an element to the queue, the rear pointer is incremented, and the
element is placed at the new rear index.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 32
MMM
 MK 5TH Semester

Before adding, a check is performed to ensure the queue is not full (i.e., rear
< max_size - 1).
Example:

def enqueue(queue, rear, element):

if rear < max_size - 1:
rear += 1
queue[rear] = element
else:
print("Queue is full")
2. Dequeue:
To remove an element, the element at the front index is returned, and front is
incremented.
A check is performed to ensure the queue is not empty (i.e., front <= rear).
Example:
def dequeue(queue, front):
if front <= rear:
element = queue[front]
front += 1
return element
else:
print("Queue is empty")
3. Peek:

This operation retrieves the front element without modifying the queue. A
check is performed to ensure the queue is not empty.
Example:

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 33
MMM
 MK 5TH Semester

def peek(queue, front):

if front <= rear:
return queue[front]
else:
return "Queue is empty"

4. IsEmpty:

This function checks if the queue is empty by returning true if front > rear.
Example:

def is_empty(front, rear):

return front > rear
5. Size:

This function returns the current number of elements in the queue by

calculating rear - front + 1.
Example:

def size(front, rear):

return rear - front + 1

Circular Queue

A circular queue is an improvement over a standard array-based queue that

resolves the problem of wasted space. In a circular queue, the last position
of the queue is connected back to the first position, forming a circle. This

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 34
MMM
 MK 5TH Semester

allows for efficient utilization of the array space, especially when elements
are dequeued.

Structure of Circular Queue

1. Array: A one-dimensional array is created to hold the queue elements.

2. Front and Rear Pointers: Two pointers (front and rear) are maintained to
indicate the front and rear of the queue, similar to a standard queue.
3. Circular Nature: When the rear pointer reaches the end of the array, it
wraps around to the beginning of the array, allowing for the reuse of empty
spaces.

Operations on Circular Queue

1. Enqueue:
When adding an element, the rear pointer is incremented in a circular
manner (using modulo operation).
Before adding, a check is performed to ensure the queue is not full.
Example:
def enqueue(circular_queue, front, rear, element):
if (rear + 1) % max_size != front: # Check for full
rear = (rear + 1) % max_size
circular_queue[rear] = element
else:
print("Queue is full")
2. Dequeue:

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 35
MMM
 MK 5TH Semester

When removing an element, the front pointer is also incremented in a

circular manner.

A check is performed to ensure the queue is not empty.

Example:
def dequeue(circular_queue, front, rear):
if front != rear: # Check for empty
element = circular_queue[front]
front = (front + 1) % max_size
return element
else:
print("Queue is empty")

Applications of Queue
Queues have numerous applications in computer science and programming,
largely due to their FIFO nature. Some notable applications include:
1. Process Scheduling:
In operating systems, queues are used for managing processes in scheduling
algorithms. Processes are added to a queue and executed in the order they
arrive, ensuring fair CPU time allocation.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 36
MMM
 MK 5TH Semester

2. Data Buffering:

Queues are commonly used in buffering data streams. For example, a printer
queue holds print jobs until they are processed in the order they were
received.

3. Breadth-First Search (BFS):

BFS is a graph traversal algorithm that uses queues to explore nodes level
by level. Nodes are added to the queue as they are discovered, allowing for
systematic exploration of all neighbors.
4. Asynchronous Data Processing:

Queues facilitate asynchronous communication between different parts of

a program or different programs. For example, web servers use queues to
manage incoming requests, processing each one as resources become
available.

5. Task Scheduling in Multi-threading:

In multi-threaded applications, queues manage tasks that need to be

executed by different threads. Tasks can be added to a queue, and worker
threads can pull tasks from the queue as they become available.

Conclusion

Queues are fundamental data structures with unique FIFO characteristics,

making them suitable for a variety of applications. The array representation

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 37
MMM
 MK 5TH Semester

of queues provides a straightforward implementation, while circular queues

enhance space efficiency by reusing empty positions. Understanding queues
and their operations is essential for implementing effective algorithms and
managing data flows in computer systems. Whether it's process scheduling,
data buffering, or task management, queues play a critical role in enhancing
system performance and ensuring smooth operations.
Unit-III: Linear Data Types - III
Q.Review of structures & pointers
Ans.Review of Structures

Structures are user-defined data types in programming languages like C and

C++ that allow for the grouping of related variables under a single name.
Each variable within a structure can be of a different data type, enabling the
creation of complex data types that represent real-world entities more
accurately. For example, a structure can represent a Person with attributes
such as name (string), age (integer), and height (float). This encapsulation of
related data provides better organization and facilitates data management in
programs.

Accessing Structure Members

Accessing the members of a structure is done using the dot operator (.) when
dealing with structure variables. For instance, if we have a structure
variable person, we can access the name using person.name. If a structure
variable is created through a pointer, the arrow operator (->) is used. This
allows for easy manipulation of structure data, whether directly or via

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 38
MMM
 MK 5TH Semester

pointers. Understanding how to navigate structure members is essential for

efficient programming and data handling.

Pointers and Their Purpose

Pointers are variables that store the memory address of another variable.
They provide powerful capabilities in C and C++ programming, such as
dynamic memory management, the ability to manipulate arrays, and the
creation of complex data structures like linked lists and trees. Pointers can
significantly enhance performance and memory efficiency by enabling direct
access to memory locations. Additionally, they allow functions to modify
variables defined outside their scope, which is critical for various
programming applications.

Using Pointers with Structures

When combined, structures and pointers enable even more flexibility in data
management. Pointers to structures can be used to dynamically allocate
memory for structures, which is essential when the number of required
structures is not known at compile time. Using pointers to structures allows
programmers to pass large structures to functions efficiently without the
overhead of copying entire structures. For example, passing a pointer to a
Person structure instead of the entire structure saves memory and processing
time.

Conclusion

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 39
MMM
 MK 5TH Semester

Understanding structures and pointers is crucial for effective programming

in languages like C and C++. Structures provide a way to group related
data logically, while pointers allow for dynamic memory management and
efficient data manipulation. Together, they enable the creation of complex
data types and sophisticated data structures, significantly enhancing the
power and flexibility of a programmer’s toolkit. Mastery of these concepts is
foundational for advanced programming techniques and systems-level
programming.
Q.Introduction to Linked Lists and their applications: Singly linked list:
Definition & Concepts, representation in memory, operations on singly
linked list (insertion, deletion, traversal, reversal).
Ans.Introduction to Linked Lists

Linked lists are dynamic data structures that consist of a sequence of

elements called nodes, where each node contains data and a reference (or
pointer) to the next node in the sequence. Unlike arrays, which have a fixed
size, linked lists can grow and shrink in size, allowing for efficient memory
utilization. This flexibility makes linked lists particularly useful in
applications where the number of elements may vary significantly. Linked
lists are foundational in computer science and serve as the building blocks
for more complex data structures like stacks, queues, and graphs.

Singly Linked List: Definition & Concepts

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 40
MMM
 MK 5TH Semester

A singly linked list is a type of linked list where each node contains two
components: the data and a pointer to the next node in the sequence. The
first node is referred to as the head, and the last node points to null,
indicating the end of the list. This one-way link structure allows for efficient
traversal in a single direction (from head to tail), making operations like
insertion and deletion straightforward. However, it does not allow for
backward traversal, which can be a limitation in certain applications.

Memory Representation

In memory, a singly linked list is represented as a collection of nodes, where

each node is typically defined as a structure containing the data and a
pointer to the next node. The memory allocated for each node can be
dynamic, which means it can be created or destroyed at runtime using
functions like malloc and free in C or new and delete in C++. This dynamic
allocation allows the linked list to efficiently use memory, as nodes can be
added or removed without the need to resize an array.

Operations on Singly Linked List

1. Insertion:

Insertion can occur at three main points: the beginning, the end, or at a
specific position in the list.

To insert a node at the beginning, a new node is created, and its next pointer
is set to the current head. The head is then updated to point to the new node.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 41
MMM
 MK 5TH Semester

For insertion at the end, the list is traversed until the last node is reached,
and the new node is linked to the last node’s next pointer.
To insert at a specific position, the list is traversed until the desired position
is found, and the new node’s pointers are adjusted accordingly.
2. Deletion:
Deletion can also occur at the beginning, end, or at a specified position.
To delete the first node, the head pointer is updated to point to the second
node in the list, effectively removing the first node.
Deleting the last node requires traversing the list to find the second-to-last
node, which will need its next pointer set to null.
For deletion at a specific position, the list is traversed to find the node just
before the target node, and the pointers are updated to bypass the node to be
deleted.

3. Traversal:

Traversal involves visiting each node in the linked list, typically starting
from the head and moving through each node using the next pointers until
the end of the list is reached (i.e., when a node points to null).
During traversal, operations can be performed on each node, such as
printing the data or performing calculations based on the node values.

4. Reversal:

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 42
MMM
 MK 5TH Semester

Reversal of a singly linked list involves changing the direction of the next
pointers so that the last node becomes the new head, and the original head
becomes the last node with its next pointer set to null.
This operation requires maintaining three pointers: previous, current, and
next. As the list is traversed, the next pointer of the current node is updated
to point to the previous node, effectively reversing the links.

Applications of Singly Linked Lists

Singly linked lists have various applications in computer science and
programming. They are commonly used in situations where dynamic data
storage is required, such as in the following scenarios:
1. Dynamic Memory Management: Linked lists can efficiently manage
memory in applications where the size of data structures can change
frequently. This is particularly useful in systems that require frequent
allocation and deallocation of memory, such as in operating systems or real-
time applications.
2. Implementing Data Structures: Many complex data structures, such as
stacks and queues, can be implemented using singly linked lists. This allows
for dynamic sizing and efficient operations on these structures, making them
suitable for various algorithms and applications.

3. File Management Systems: Singly linked lists can be used to represent

files and directories in file management systems. Each file or directory can
be represented as a node, and the links can denote the hierarchical structure
of files and directories, allowing for efficient navigation and management.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 43
MMM
 MK 5TH Semester

4. Polynomial Representation: In mathematics, polynomials can be

represented using singly linked lists, where each node contains a coefficient
and an exponent. This representation allows for efficient addition,
subtraction, and multiplication of polynomials, facilitating computations in
computer algebra systems.
5. Adjacency Lists for Graphs: In graph theory, singly linked lists can
represent adjacency lists, where each node represents a vertex, and the links
to other nodes represent edges. This representation is memory-efficient and
allows for quick access to neighbors of a vertex.

Conclusion

Singly linked lists are fundamental data structures that provide dynamic
memory management and efficient operations for storing and manipulating
collections of data. Their unique characteristics and flexibility make them
suitable for a wide range of applications in computer science, from basic
data structure implementations to complex systems like file management and
graph representations. Understanding singly linked lists, their operations,
and their applications is essential for any aspiring programmer or computer
scientist.

Q.Variations of Linked List (Doubly linked list, circular linked list)

Ans.Variations of Linked Lists
Linked lists come in various forms to suit different applications and
requirements. Two notable variations are doubly linked lists and circular

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 44
MMM
 MK 5TH Semester

linked lists. Each has unique characteristics that allow for specific
operations and optimizations.
Doubly Linked List

A doubly linked list is a variation of the standard linked list in which each
node contains three components: the data, a pointer to the next node, and a
pointer to the previous node. This means that each node can be traversed in
both directions (forward and backward). The first node is still called the
head, and the last node points to null for both next and previous pointers.

Advantages:

Bidirectional Traversal: The ability to traverse the list in both directions

makes it easier to implement certain algorithms and operations, such as
searching and insertion at both ends.

Easier Deletion: In a doubly linked list, deleting a node is more efficient

because the pointer to the previous node is available, allowing direct access
to adjust pointers without needing to traverse the list.

Insertion Flexibility: Insertion can be done more easily at both the front and
the back, as well as at any position, since both previous and next pointers
can be easily manipulated.
Operations:
1. Insertion: Similar to singly linked lists, but requires updating both the next
and previous pointers of the adjacent nodes.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 45
MMM
 MK 5TH Semester

2. Deletion: Involves adjusting the pointers of the neighboring nodes to

bypass the node being deleted.
3. Traversal: Can be performed in both directions, allowing for more flexible
access to elements.

Circular Linked List

A circular linked list is a variation where the last node points back to the
first node, forming a circle. Circular linked lists can be either singly or
doubly linked. In a singly circular linked list, each node has a next pointer
pointing to the subsequent node, while in a doubly circular linked list, each
node has both next and previous pointers.

Advantages:

Continuous Traversal: In a circular linked list, traversal can continue

indefinitely without needing to reset to the head, making it ideal for
applications that require repetitive looping through the list.

Efficient Use of Memory: Circular linked lists can efficiently utilize memory
by avoiding null pointers at the end of the list, which can be beneficial in
certain applications.

Easy Implementation of Queues: Circular linked lists are often used to

implement circular queues, where the front and rear can easily wrap
around to the beginning of the list.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 46
MMM
 MK 5TH Semester

Operations:

1. Insertion: Similar to singly linked lists, but when inserting at the end, the
new node’s next pointer should point to the head, and the previous last
node’s next pointer should point to the new node.
2. Deletion: Requires careful handling of the pointers to maintain the
circular structure while removing a node.
3. Traversal: Can start from any node and continue until a full loop is
completed, allowing for versatile access patterns.

Conclusion

Both doubly linked lists and circular linked lists are powerful variations of
standard linked lists, each with its advantages and suitable applications.
Doubly linked lists facilitate easier manipulation and traversal of elements in
both directions, while circular linked lists offer a continuous traversal
mechanism ideal for certain applications like queues and repeated cycles.
Understanding these variations expands the toolbox for programmers and
allows for more efficient data management in various scenarios.

Q.Linked list implementation of Stack and Queue

Ans.Linked List Implementation of Stack

A stack is a linear data structure that follows the Last In, First Out (LIFO)
principle, where the last element added is the first to be removed.
Implementing a stack using a linked list involves utilizing a singly linked list
where each node contains the stack element and a pointer to the next node.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 47
MMM
 MK 5TH Semester

The head of the linked list serves as the top of the stack, enabling efficient
push and pop operations.

In this implementation, the push operation adds a new node at the head of
the list. When a new element is added, a new node is created, and its next
pointer is set to the current head. The head is then updated to point to the
new node. Conversely, the pop operation removes the node at the head. This
involves retrieving the data from the head node, updating the head to point
to the next node, and then freeing the memory of the removed node. Both
operations have a time complexity of O(1), making the linked list
implementation of the stack efficient in terms of both time and space.

Linked List Implementation of Queue

A queue is another linear data structure that follows the First In, First Out
(FIFO) principle, where the first element added is the first to be removed. To
implement a queue using a linked list, a singly linked list can again be
employed, but with both a front pointer (to access the head of the list) and a
rear pointer (to access the last node). The front pointer facilitates efficient
dequeue operations, while the rear pointer allows for efficient enqueue
operations.

In this implementation, the enqueue operation involves adding a new node at

the end of the list. A new node is created, and its next pointer is set to null. If
the queue is empty, both the front and rear pointers point to this new node. If
not, the current rear node's next pointer is updated to point to the new node,
and the rear pointer is updated to the new node. The dequeue operation

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 48
MMM
 MK 5TH Semester

removes the node at the front. This operation retrieves the data from the
front node, updates the front pointer to the next node, and frees the memory
of the removed node. Like the stack implementation, both operations for the
queue also have a time complexity of O(1).

Advantages of Linked List Implementation

Using linked lists for stack and queue implementations offers several
advantages. First, there is no need to define a fixed size, which addresses the
limitation of static data structures like arrays that may require resizing. The
dynamic nature of linked lists allows for efficient memory use, especially
when the number of elements fluctuates frequently. Furthermore, operations
such as insertion and deletion can be performed without shifting elements,
which is necessary in array-based implementations, making linked lists
generally more efficient for these operations.

Considerations and Trade-offs

While linked list implementations of stacks and queues offer flexibility and
efficiency, they also come with certain trade-offs. The primary concern is
memory overhead due to the storage of pointers in each node, which can be
significant in memory-constrained environments or for small data types.
Additionally, linked lists incur a slight overhead in terms of performance due
to the increased number of memory allocations and deallocations compared
to contiguous memory allocations in arrays. However, these trade-offs are
often justified in applications that require dynamic sizing and frequent
changes in the number of elements.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 49
MMM
 MK 5TH Semester

Conclusion

The linked list implementation of stacks and queues is a powerful technique

in computer science that leverages the dynamic nature of linked lists to
provide efficient and flexible data structures. By allowing for easy insertion
and deletion without the constraints of fixed sizes, linked lists are
particularly suited for scenarios where the size of the data structure is
unpredictable. Understanding these implementations is crucial for
developing effective algorithms and data management solutions in various
programming applications.

Unit-IV: Non-Linear Data Types (15 Lectures

Q.Trees: Introduction to trees, terminology, Binary Trees, Binary tree
representation and traversals (in-order, pre-order, post-order), Binary
Search Trees, Applications of trees
Ans.Introduction to Trees

A tree is a widely used data structure in computer science that simulates a

hierarchical tree structure. It consists of nodes connected by edges, with a
single node designated as the root. Each node can have zero or more child
nodes, and nodes without children are known as leaves. Trees are
particularly useful for representing relationships among data elements, such
as organizational structures, file systems, and even data processing

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 50
MMM
 MK 5TH Semester

pipelines. The hierarchical nature of trees allows for efficient organization

and retrieval of data.

Terminology

In the context of trees, several key terms are important to understand. The
root is the topmost node in the tree, while the height of a tree is the length of
the longest path from the root to a leaf. Each node in a tree can have
subtrees, which are smaller trees formed by its child nodes. The degree of a
node refers to the number of children it has. Trees can be classified into
different types based on their structure and properties, such as binary trees,
where each node has at most two children. Understanding these
terminologies is essential for effectively working with trees in various
applications.

Binary Trees

A binary tree is a specific type of tree where each node has at most two
children, referred to as the left and right child. This structure provides a
clear and efficient way to store and manipulate data. In binary trees, each
node can represent data and pointers to its child nodes, facilitating efficient
traversal and searching. Binary trees can be further categorized into several
types, including full binary trees (where each node has either 0 or 2
children), complete binary trees (where all levels are fully filled except
possibly the last), and perfect binary trees (where all leaf nodes are at the
same level).

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 51
MMM
 MK 5TH Semester

Binary Search Trees (BST)

A binary search tree (BST) is a specialized form of a binary tree that

maintains a sorted order of elements. In a BST, for each node, all elements
in the left subtree are less than the node, and all elements in the right subtree
are greater. This property enables efficient searching, insertion, and deletion
operations, each with an average time complexity of O(log n) when the tree
is balanced. BSTs are widely used in applications where dynamic data
storage and retrieval are necessary, such as database indexing and in-
memory data management.

Applications of Trees

Trees have numerous applications across various fields of computer science

and data management. They are extensively used in database systems for
indexing and querying data efficiently. Trees also form the backbone of
various algorithms, such as Huffman coding for data compression and
decision trees for machine learning. Additionally, trees play a crucial role in
representing hierarchical data structures, such as file systems, where
directories can contain subdirectories and files. The versatility and efficiency
of trees make them an indispensable data structure in both theoretical and
practical applications.
Q.Graphs: Introduction, terminology, linked and matrix representation,
Traversing a Graph: BFS, DFS. Dijkstra's Shortest Path Algorithm.
Applications of graphs
Ans.Introduction to Graphs

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 52
MMM
 MK 5TH Semester

A graph is a fundamental data structure in computer science that consists of

a set of nodes (or vertices) connected by edges (or arcs). Graphs can
represent various real-world structures, such as social networks,
transportation systems, and communication networks. They provide a
versatile way to model relationships and facilitate the analysis of
interconnected data. Graphs can be classified into different types, including
directed and undirected graphs, weighted and unweighted graphs, and cyclic
and acyclic graphs, depending on the properties of the nodes and edges.

Terminology

Understanding the terminology associated with graphs is crucial for

effectively working with them. The vertices are the individual elements or
nodes of the graph, while the edges are the connections between pairs of
vertices. A path is a sequence of edges that connects two vertices, and a
cycle is a path that starts and ends at the same vertex. The degree of a vertex
is the number of edges connected to it; in directed graphs, this is often
broken down into in-degree (incoming edges) and out-degree (outgoing
edges). Other important concepts include connected graphs (where there is a
path between every pair of vertices) and disconnected graphs (where at least
one pair of vertices has no path between them).

Graph Representation

Graphs can be represented using various methods, primarily adjacency

lists and adjacency matrices.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 53
MMM
 MK 5TH Semester

Linked Representation (Adjacency List): In this method, each vertex

maintains a list of its adjacent vertices. This representation is efficient in
terms of space, especially for sparse graphs (graphs with relatively few
edges compared to the number of vertices). Each vertex is an entry in an
array or linked list, and each entry contains a list of edges connected to that
vertex.

Matrix Representation (Adjacency Matrix): This representation uses a two-

dimensional array (or matrix) where the rows and columns represent
vertices. An entry at position (i, j) indicates the presence (and sometimes the
weight) of an edge between vertices i and j. While this representation is
straightforward and allows for quick edge lookups, it can consume more
memory, especially for dense graphs.

Graph Traversal: BFS and DFS

Graph traversal refers to the process of visiting all the vertices and edges of
a graph. Two common traversal algorithms are Breadth-First Search (BFS)
and Depth-First Search (DFS).

BFS explores the graph level by level, starting from a selected vertex (the
root). It uses a queue data structure to keep track of vertices that need to be
explored. BFS is particularly useful for finding the shortest path in
unweighted graphs and is often used in applications such as web crawling
and social network analysis.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 54
MMM
 MK 5TH Semester

DFS, on the other hand, explores as far as possible along each branch
before backtracking. It can be implemented using recursion or a stack. DFS
is beneficial for tasks like topological sorting and cycle detection and is often
used in algorithms that require exploring all possible paths, such as maze
solving.

Dijkstra's Shortest Path Algorithm

Dijkstra's algorithm is a widely used method for finding the shortest path
from a source vertex to all other vertices in a weighted graph. It operates by
maintaining a priority queue of vertices to explore, starting from the source
vertex with a distance of zero. As the algorithm progresses, it continually
updates the shortest known distance to each vertex, exploring the lowest-cost
paths first. Dijkstra's algorithm is particularly effective in applications like
GPS navigation systems, network routing protocols, and various
optimization problems in logistics.

Applications of Graphs

Graphs are used extensively across various domains due to their ability to
model complex relationships and structures. In computer science, they are
essential in algorithms for network routing, social network analysis, and
recommendation systems. In biology, graphs help model protein interactions
and gene regulatory networks. In transportation, graphs represent routes in
logistics and supply chain management. Moreover, they are used in artificial
intelligence for problem-solving tasks, such as planning and decision-

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 55
MMM
 MK 5TH Semester

making. The versatility of graphs makes them a fundamental concept in both

theoretical and practical applications in computer science and beyond.

MMMMMMMMMMBBMMMMMMMMMMMMMMMMMMMMMMMMMMMM 56
MMM