DATA STRUCTURE AND ALGORITHM for beginners

DATA STRUCTURE AND ALGORITHM-
IN23C05
Dr Sabitha Banu
Assistant Professor
PSGR Krishnammal College for Women
12-12-2023 Dr Sabitha Banu,Assistant Professor ,PSGRKCW 1

Course Outcomes
•Recall about the concepts of Arrays, Stack, Queue, Link List, Trees and
Graph.
•Understand sorting, searching and hashing algorithm
•Apply the data structures to solve various computing algorithms and
sorting algorithms.
•Analyze lists, queues, stacks, trees and graph according to the needs
of different applications

UNIT-I
•Introduction to Data Structure
Definition, Basic Terminology, Elementary Data Organization
Types of Data Structures- Linear & Non-Linear Data Structures
Data Structure Operations
•Algorithm Specifications:
Performance Analysis and Measurement (Time and space analysis)
• Abstract Data Types
Advantages of ADT
• Array
Representation of arrays
Types of arrays
Applications of arrays
Sparse matrix and its representation

Definition of Data Structure
•Logical or mathematical model of the organization of data elements
in the computer memory.
•Algorithms-Specific methods used to access and process the data
elements
•Organizing the data + processing the data from
memory(main+Secondary) collectively –Data Structures
•Basic building blocks of the program

Linear Data Structures
•The data is stored in linear data structures sequentially.
•These are rudimentary structures since the elements are stored
one after the other without applying any mathematical
operations.
Examples
•Arrays
•Linked Lists
•Stacks
•Queues

Non-Linear Data Structures
•Non-Linear data structures store the data in the form of a hierarchy.
•data can be found in multiple levels and are difficult to traverse
through.
Examples
•Tree
•Graph

Common Operations
✔ Traverse
✔ Search
✔ Insert
✔ Delete
✔ Sort
✔ Merge
✔ Create
✔ Retrieve
✔ Store

Algorithm
•step-by-step procedure
•Pseudo code
•Algorithm writing is a process and is executed after the problem
domain is well-defined.
•Instructions are applied on raw data –input, solution of the problem is
produced-output
•Example

•https://algodaily.com/lessons/algorithm-examples-everyday-life

Characteristics of an algorithm
•Input value must be given to solve the computational problem
•Algorithms process the data by applying some operations ,desired
output is generated
•Algorithms must terminate after some instructions and reach the
concluding state

Advantages of Algorithms:
•It is easy to understand.
•An algorithm is a step-wise representation of a solution to a given
problem.
•In Algorithm the problem is broken down into smaller pieces or steps
hence, it is easier for the programmer to convert it into an actual
program.
Disadvantages of Algorithms:
•Writing an algorithm takes a long time so it is time-consuming.
•Understanding complex logic through algorithms can be very difficult.
•Branching and Looping statements are difficult to show in Algorithms

Flowchart
•A flowchart is a graphical representation of
an algorithm.
•makes use of symbols that are connected
among them to indicate the flow of
information and processing.

Analysis of Algorithms
•Provides theoretical estimation for the required resources of an
algorithm to solve a specific computational problem.
•Analysis of algorithms is the determination of the amount of time and
space resources required to execute it.
•Efficiency(CPU, Memory ,Disk, Network )
•Time complexity
•Space complexity
•Worst, Average and Best Cases

Abstract Datatypes (ADT)
•Is a mathematical tool used to define the concept of data types and
set of operations
•Collection of data values and the functions which operate on these
values

Arrays
•fixed-size sequenced collection of variables belonging to the same data types
and stored in contiguous memory.
•Set of pairs, index or value
•The array has adjacent memory locations to store values.
•convenient structure for representing data
•Two terms to understand the concept of array are Element and Index
✔ Element − Each item stored in an array is called an element.
✔ Index − Each location of an element in an array has a numerical index, which is used to
identify the element.
data_type array_name [array_size];

• Index starts with 0.
• Array length is 10 which means it can store 10 elements.
• Each element can be accessed via its index(mapping). For example, we can fetch an
element at index 6 as 9.
#
structure ARRAY(value, index)
declare CREATE( ) array
RETRIEVE(array,index) value
STORE(array,index,value) array;
#
Need for Arrays
• number of variables used will increase

Ordered Lists
• list in which the elements must always be ordered in a particular way
• Also called as Sorted list.
Eg. (SUNDAY ,MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
SATURDAY)
Representation of arrays
✔ One dimensional array
❖ A one-dimensional array is also called a single dimensional array where the elements will be accessed in
sequential order. This type of array will be accessed by the subscript of either a column or row index. eg
a[n] or an
✔ Two dimensional array
❖ When the number of dimensions specified is more than one, then it is called as a
multi-dimensional array. Eg a[3,3] (row x column)

Eg a[3][4]
• A two-dimensional array will be accessed by using the subscript of row and column
index.
eg a[1][1]

1D or one dimensional array-
•A list of items having one variable name with only one subscript
•Computer reserves 5 storage locations
•Int number[5]={35,40,20,57,19}

Char name[10]=“well done”;
When declaring a character arrays ,allocate one extra element space
for the null terminator
When a compiler reads a character arrays it terminates with the
additional null character(‘0’)

•Two different types of initialization of arrays
• Compile time initialization
• Run time initialization
Compile time Initialization

•Run time initialization

Two Dimensional Array-
•To store a table of values
•C allows us to store the table of values using 2D or two dimensional array
•Two dimensional array can be declared as
•C places each size its own set of brackets.

Initializing an 2D array –
1. 6.
2. 7.
3.
4.
5.

Memory Layout-
•The subscripts in the 2d arrays represents the rows and columns
•The elements of the array are stored contiguously in increasing memory
locations.
•Starts to store row wise ,starting from the first row and ending with the last
row, treating each row like a simple array.
A[3][3]={{10,20,30},{40,50,60},{70,80,
90}};

Multi-dimensional array-
•C allows arrays of 3 or more dimensions.the exact limit is decided by the
compiler
•There is no limit for dimensions but compiler permits only 7-10 dimensions.

Different types of representation
• Square matrix
• Diagonal
• Row
• Zero
• Upper triangular matrix
• Lower triangular matrix
• Scalar matrix
• identity/Unit matrix

Square matrix
• Number of rows=number of columns

Diagonal matrix
• Where diagonal elements are non-zero elements

Row matrix
Matrix consists of one row

Zero matrix
Matrix where all the elements have zero value

Upper& lower triangular matrix
● A square matrix is said to be a lower
triangular matrix if all the elements above its
main diagonal are zero.
● A square matrix is said to be an upper
triangular matrix if all the elements below
the main diagonal are zero.

Scalar matrix
Matrix where all diagonal elements are same

identity/unit matrix
All diagonal elements are 1

Unit-2
Stacks and Queues
• Stack
• Stack Representation & Implementation
• Stack Operations
• Applications of Stack
• Queue
• Queue Representation & Implementation
• Queue Operations
• Types of Queues

Stack
• simple data structure used for storing data
• In a stack, the order in which the data arrives is
important
• Definition
“A stack is an ordered list in which insertion and
deletion are done at one end, called top. The last
element inserted is the first one to be deleted.
Hence, it is called the Last in First out (LIFO) or
First in Last out (FILO) list”
• https://www.youtube.com/watch?v=-qsKQVpGPKs

Operations
• When an element is inserted in a stack, the
concept is called push
• when an element is removed from the stack, the
concept is called pop.
• Trying to pop out an empty stack is called
underflow
• trying to push an element in a full stack is called
overflow

Main stack operations
• Push (int data): Inserts data onto stack.
• int Pop(): Removes and returns the last
inserted element from the stack.

Auxiliary stack operations
• int Top(): Returns the last inserted element without removing
it.
• int Size(): Returns the number of elements stored in the
stack.
• int IsEmptyStack(): Indicates whether any elements are
stored in the stack or not.
• int IsFullStack(): Indicates whether the stack is full or not.

Stack Implementation
• Simple array /Static array based
implementation
• Dynamic /pointer/Linked lists
implementation

Simple Array Implementation
• uses an array
• In the array, elements are added from left to
right and use a variable to keep track of the
index of the top element.

• The array storing the stack elements may
become full. A push operation will then
throw a full stack exception.
• Similarly, if we try deleting an element from
an empty stack it will throw stack empty
exception.

Dynamic /pointer representation
• Do not have size limitations and use space proportional to
the actual number of elements stored in the stack
• Also called as linked representation of stack /linked stack
Linked representation
• Stack is a collection of nodes
• Each is divided into 2 parts
• Info-element ,next-pointer of the
neighbour element

• Top -start pointer of the stack
• If the last node link field contains null /Top=null-bottom of
the stack
•

Multiple Stacks
❖ a single array having more than one stack. The array is divided for
multiple stacks.
❖ If the array represents two stacks ,then two stacks can grow
in the opposite direction

❖ Suppose there is an array STACK[n] divided into two stack STACK A
and STACK B, where n = 10.
➢ STACK A expands from the left to the right, i.e., from 0th
element.
➢ STACK B expands from the right to the left, i.e., from 10th
element.
➢ The combined size of both STACK A and STACK B never
exceeds 10.

Queues
• Linear data structure in which elements can be inserted at
one end(REAR) and deleted from other end (FRONT)
• Elements are processed based on the order of arrival
• First Come First Serve (FCFS)/FIFO (First In First Out)
•
•

• Queue is an integral part of OS
• Process management and multiprogramming environment

Queue representation and
implementation
❖ Two kinds of representation
➢ Static /sequentially /array representation
➢ Dynamic /pointer /linkedlist
representation

Array representation
• A queue is implemented with max elements
array stored from queue[i] to queue[j],Max
• I,j are front(F) and Rear(R)
• Contains two pointer variables
• Front -location of the front element of the queue
• Rear-location of the rear element of the queue

Dynamic /Pointer representation
• Size of the queue is not constant which is called
dynamic
• Also called as Linked representation of queue
• Linked queue
Linked queue
• Implemented as a linked list with two pointer variables
• Front and Rear (pointing to the front and rear nodes of
the queue)

Stack vs Queue
Stack Queue
Can be implemented sequentially and
dynamically
Can be implemented sequentially and
dynamically
Are called LIFO Called FIFO
One entry and exit called Top Separate entry called Rear and separate
exit called Front
No different forms of stacks Different forms of queue circular,priority ,
dequeue

Drawback of queue
• Queue is completely full when rear is at last array
position i.e. (MaxSize -1).
• Now no more elements can be inserted in queue
even if the queue has some empty spaces.

Circular Queue
• Removes the drawback of simple queue
• the last element is connected to the first element,
creating a circular structure.
• This allows for efficient use of
memory.
• FIFO basis
•

• Let’s say the MaxSize of your queue is 5, and the rear pointer has
already reached the end of a queue.
• There is one empty space at the beginning of a queue, which
means that the front pointer is pointing to location 1.

Enqueue(x) Operation
Step 1: Check if the queue is full (Rear + 1 % Maxsize = Front)
Step 2: If the queue is full, there will be an Overﬂow error
Step 3: Check if the queue is empty, and set both Front and Rear
to 0
Step 4: If Rear = Maxsize - 1 & Front != 0 (rear pointer is at the
end of the queue and front is not at 0th index), then set Rear = 0
Step 5: Otherwise, set Rear = (Rear + 1) % Maxsize
Step 6: Insert the element into the queue (Queue[Rear] = x)
Step 7: Exit

Deque
❖ Double ended queue where insertion and deletion can
be performed in both ends front and rear
❖ Rear is incremented by 1 nd then it is inserted in the
new location
❖ Similarly when the element is deleted front is
incremented by 1
❖ Elements can be inserted in the front
➢ Front is decremented to 1 before insertion and the
element is inserted into the new location
➢ Front is 0 ,overflow occurs
❖ Elements can be deleted from the rear
➢ Rear is decremented by 1 after the deletion
➢ Deleted element returned to the user

Dequeue() Operation
Step 1: Check if the queue is empty (Front = -1 & Rear = -1)
Step 2: If the queue is empty, Underflow error
Step 3: Set Element = Queue[Front]
Step 4: If there is only one element in a queue, set both Front
and Rear to -1 (IF Front = Rear, set Front = Rear = -1)
Step 5: And if Front = Maxsize -1 set Front = 0
Step 6: Otherwise, set Front = Front + 1
Step 7: Exit

Different types of Deque
Input Restricted
Where insertion is restricted to one end (rear end )and
deletion can be done both ends,front & rear
Output Restricted
Where deletion is restricted to one end (front end )and
insertion can be done both ends,front & rear
Circular Dequeue
Implemented in Circular form,last element follows the first
element

Priority Queue
➔ Insertion and deletion is done according to the priorities
assigned
➔ Does not follow any principles FIFO
➔ Elements of higher priorities are processed first than the
elements with the lowest priorities
➔ If both have same priorities then based on the order of
insertion
➔ Used in OS for time sharing property
➔ Insertion of an element is difficult than deletion (finding out
the correct location according to the priority)
➔ Two ways
◆ Sequential /array
◆ dynamic/linked info Priority
no
pointer

Multiqueue
• Multi queue is data structure in which multiple queues are maintained.
• are utilized for process scheduling.
• one dimensional array or multidimensional array to illustrated a
multiple queue.
• Each of queues contains n elements that are mapped to a linear array of m
elements.

Applications of stack
• Factorial of a given number
• Recursion
• Infix to Postfix transformation

Recursion
• a function or method has the ability to call itself to solve the problem.
• Recursion in stack in data structure is when functions call themselves
directly or indirectly.

Factorial of a given number(Recursion)

• First, convert the given expression into special notation.
• Evaluate the expression in this new notation
• three notations to represent an arithmetic expression:
❖ Infix Notation
❖ Prefix Notation
❖ Postfix Notation

Infix
• The infix notation is a convenient way of writing an
expression in which each operator is placed
between the operands.
• Infix expressions can be parenthesized or
unparenthesized depending upon the problem
requirement
• Example A + B, (C - D)
• All these expressions are in infix notation because
the operator comes between the operands.

Prefix Notation
• The prefix notation places the operator before
the operands.
• This notation was introduced by the Polish
mathematician and hence often referred to as
polish notation
• Example: + A B, -CD etc
• All these expressions are in prefix notation
because the operator comes before the
operands.

Postfix Notation
• The postfix notation places the operator after
the operands.
• This notation is just the reverse of Polish
notation and also known as Reverse Polish
notation.
• Example: AB +, CD+, etc.
• All these expressions are in postfix notation
because the operator comes after the operands

Infix Notation
(A*B)
(A+B)/C
(A*B)+(D-C)

example of Converting an infix expression
into a postfix expression

Evaluating a postfix expression
3 + 8 - 9 / 8
= 3 + 8 - 1.125
= 11 - 1.125
= 9.875

Sum of n number using Recursion
#include <stdio.h>
int sum(int n);
int main() {
int number, result;
printf("Enter a positive integer: ");
scanf("%d", &number);
result = sum(number);
printf("sum = %d", result);
return 0;
}
int sum(int n) {
if (n != 0)
// sum() function calls itself
return n + sum(n-1);
else
return n;
}

Factorial of given number
#include<stdio.h>
long factorial(int n)
{
if (n == 0)
return 1;
else
return(n * factorial(n-1));
}
void main()
{
int number;
long fact;
printf("Enter a number: ");
scanf("%d", &number);
fact = factorial(number);
printf("Factorial of %d is %ldn",
number, fact);
return 0;
}

Recursion Iteration
When a function calls itself Set of statements executed repeatedly until the condition is
satisfied
Based on base condition Initialization,termination,incrementation,updation ,execution
Top-down approach Bottom up approach
Takes more space to store new set of
variables
Does not take much space and time
Not efficient Efficient
Recursive algorithm can be converted to
iterative version
Iterative cannot be converted to recursive version
Saves the return address Does not save the return address
Uses stack for temporary storage Stacks are not required to implement iterative algorithms

#include <stdio.h>
int MAXSIZE = 8;
int stack[8];
int top = -1;
/* Check if the stack is empty */
int isempty(){
if(top == -1)
return 1;
else
return 0;
}
/* Check if the stack is full */
int isfull(){
if(top == MAXSIZE)
return 1;
else
return 0;
}
/* Function to return the
topmost element in the stack */
int peek(){
return stack[top];
}

/* Function to delete from the stack
*/
int pop(){
int data;
if(!isempty()) {
data = stack[top];
top = top - 1;
return data;
} else {
printf("Could not retrieve data,
Stack is empty.n");
}
}
/* Function to insert into the stack
*/
int push(int data){
if(!isfull()) {
top = top + 1;
stack[top] = data;
} else {
printf("Could not insert data,
Stack is full.n");
}
}

/* Main function */
int main(){
push(44);
push(10);
push(62);
push(123);
push(15);
printf("Element at top of the
stack: %dn" ,peek());
printf("Elements: n");
// print stack data
while(!isempty()) {
int data = pop();
printf("%dn",data);
}
printf("Stack full: %sn" ,
isfull()?"true":"false");
printf("Stack empty: %sn" ,
isempty()?"true":"false");
return 0;
}

UNIT-III
Linked List
• Linked List as Data Structures
• Representation of Linked List
• Operations on Linked List
• Stack as Linked List
• Queue as Linked List
• Doubly Linked List
• Circular List

Linked List as Data Structures
• Collection of similar elements where each element points to the next
element
• Is a linear data structure
• Each node divided into two parts
• Info -contains the info about the items of the list stored and processed
• Next-contains the address of next adjacent node .used to access the next
data item maintained in the other node,maintains the link of the data
• A linked list can grow and shrink its size(dynamic), as per the requirement.
• It does not waste memory space.
• Data items in the list are not maintained in contiguous locations ,may placed
anywhere
• Correct order is maintained by the logical address in the next field of each
node,insertion and deletion is possible

• Access the data items of the linked list sequentially
• Random access of items is not allowed ,coz they are
linked through pointers

Represeantion of linked list
• Static /sequential/array representation
• dynamic/pointer/linked representation

Static /sequential/array representation
• Linked list can also be implemented as an array
• Data items maintained in two parallel arrays of the
same sizes
• One array for storing info field of the nodes
• Other array for the addresses

List[n] -number of nodes in the list
List[6].info=16
List[6].field=10

• Array representation is not flexible
• Size of the linkedlist may increase/decrease as per the
requirement when insertion and deletion is done
• Dynamic representation does not have size limitations
• Space proportional to the actual no of elements

• In C language, a linked list can be
implemented using structure
and pointers
• is used to create every node in
the list
• The data field stores the element
and the next is a pointer to store
the address of the next node
• In place of a data type, struct
LinkedList is written before next.
• That's because its a
self-referencing pointer. It
means a pointer that points to
whatever it is a part of. Here next
is a part of a node and it will
point to the next node.

Operations on the linkedlist
• Creation
• Traversal - To access each element of the linked list.
• Insertion - To add/insert a new node to the list.
• Deletion - To remove an existing node from the list.
• Search - To find a node in the list.
• Sort - To sort the nodes.

Create linkedlist
• Creation of the linkedlist
Array implementation-
❖ Number of nodes declared in advance
❖ Elements are entered in the contiguous
memory locations
❖ Placed sequentially in the array
❖ Maintain the list of free nodes
❖ Initially all the nodes are empty then
linked with one another in sequence
❖ next pointer=-1 denotes end of the list

Dynamic implementation
• List is created by creating the nodes of the list as
and when required
• Allocate memory dynamically

• Define the structure of a node and define
start pointer to the node type
struct Node
{
int info;
Node *next;
};
struct node *start;
● In linked lists, a struct is
used to define the structure
of each node in the list.
● Each node typically
contains two parts: the
data and a reference (or
pointer) to the next node in
the sequence.
● The struct allows you to
group these two pieces of
information together.

2. Set start =NULL to indicate the list is initially empty.
start=NULL;
3. Get the free new node from the memory heap assign its
address into pointer ptr.
struct Node* newNode = (struct
Node*)malloc(sizeof(struct Node));
4. Assign the value to be inserted to the info part of the new
node pointed by ptr
ptr→info=value(first supply the value)
5.Assign NULL to the next part of the new node
ptr→next=start(ptr→next=NULL becoz start=NULL
6.Assign the address of the first node to the start variable
start=ptr
7.Return

int main() {
struct Node* head = NULL;
struct Node* second_node = NULL;
struct Node* third_node = NULL;
// Allocate memory to 3 nodes
head = (struct Node*)malloc(sizeof(struct Node));
second_node = (struct Node*)malloc(sizeof(struct
Node));
third_node = (struct Node*)malloc(sizeof(struct Node));
head->data = 12; //assign data in first node
head->next = second_node; // Link first node with the
second node.
second_node->data = 99; //assign data to second node
second_node->next = third_node; // Link second node
with the third node
third_node->data = 58; //assign data to third node
third_node->next = NULL;}

Traversing a linkedlist
• Is used to visit each node of the list exactly once in
order to access the information stored in the
nodes
• Accessing or printing the values (i.e., data items stored
inside each node) of a singly linked list exactly once
until the end node is reached.
• This accessing and printing is sometimes called “visiting”
the linked list
• Accessing or printing of nodes always takes place one by
one
• The process of visiting each node of the list once to
perform some operation on it is called traversing

1.node creation
2.memory allocation
3.setting head
4.The malloc function in C returns a pointer to the ﬁrst byte of the allocated
memory block, and its return type is void *.
5.type casting

Insertion of an element into the linked list at
various positions
● Requires a free node in which the information is to be
inserted
● Then the node can be inserted into the linked list
● Pointers are adjusted
● Three possible positions where we can enter a new node
in a linked list –
★ Insertion at beginning
★ Insertion after nth position
★ Insertion at end

Steps :
1. Get the free node from memory pool and assign its address
to the ptr
2. Assign the value ptr→info=value to the info part of the new
node pointed by the ptr
3. If the linked list is empty start=NULL then assign ptr→next =
start and start =ptr

4. Otherwise adjust the pointers according to the place of
insertion.

Insertion at the beginning
• Create a new node
• Assign its data value
• Assign newly created node’s next ptr to current head
reference. So, it points to the previous start node of the
linked list address
• Change the head reference to the new node’s address.

void insertStart (struct Node *head, int data)
{
struct Node *newNode = (struct Node *) malloc
(sizeof (struct Node));
newNode - > data = data;
newNode - > next = *head;
//changing the new head to this freshly entered
node
*head = newNode;
}

Insertion at the end of the list
● Create a new node
● Assign its data value
● Assign its next node to NULL as this will be the last(tail) node
● Check if the list is empty
○ Change the head node to the new node
● If not then traverse till the last node
● Assign the last node’s next pointer to this new node
● Now, the new node has become the last node.

Insertion at the specified position in the
linkedlist
• First ,create a new node named by newnode and put the position
where u want to insert the node.
• Now give the address of the new node in previous node means link
the new node with previous node.
• After this, give the address of current node in new node.Means link
your new node also with current node.

Deletion of an element from the linkedlist
• No longer nodes can be deleted from the list
• Can be performed at various positions like linkedlist
• Necessary to know the position of the node to be
deleted
• Check for the underflow condition (list=NULL)
• Deletion at the beginning
• Deletion at the end
• Deletion at the middle

Deletion at the beginning of the list
• Check for the underflow condition
• First node to be deleted start pointerpoint to the
second node of the list
• After deleting save the value into a variable
• Deleted nodesent to the memory for future use
• free() ,delete()

Deletion at the end of the list
• Traverse the entire list to find the address of the second
last node to adjust the pointers
• next field of the second last node point to the next field
of the last node
• Hence the next field of the second last node will contain
now NULL
• Contains a temporary pointer to hold the address of the
preceding node (node to be deleted)

Step 1: IF HEAD = NULL
Write UNDERFLOW
Go to Step 8
[END OF IF]
Step 2: SET PTR = HEAD
Step 3: Repeat Steps 4 and 5 while PTR ->
NEXT!= NULL
Step 4: SET PREPTR = PTR
Step 5: SET PTR = PTR -> NEXT
[END OF LOOP]
Step 6: SET PREPTR -> NEXT = NULL
Step 7: FREE PTR
Step 8: EXIT

Representation of linked list
Array Pointer(linkedlist)
Fixed size,cannot grow according to the
need,hard to predict the size every time
Elements can be added indefinitely,grow during the
execution time
Static,fixed size,easy to use Dynamic,does not require to predict in advance
Deletion leaves an empty space (wasting of
memory),shifting of elements is difficult
Elements can be deleted ,can shrink during the
execution time
Insertion and deletion is slow,needs to shift
operation
Insertion and deletion is fast
Memory allocated at compile time ,memory
does not used efficiently
Efficiently utilizes the memory ,bcoz memory is
allotted at runtime
Insertion and deletion at specified position
needs resizing of the array which is not
Insertion and deletion at specified position by
adjusting the pointers ,it is flexible

Random access to the elements Allows sequential access to the elements
Suits smaller list of elements when numbers
of items in the list is known
Larger list where insertion and deletion is done
frequently
Pass through all the elements to reach kth
element
Access directly in a single operation by using the
index value

Stack as a linkedlist
Array implementation
• Size of the stack is known in advance
• Advance declaration of maximum size is
not possible all the time
• Size may increase or decrease according
to the requirement
• Size constantly change as items pushed
and popped

Dynamic representation of a stack:
• Called as linked stack/linked list
• Suits for large records and when elements are
not known in advance
• Stack is represented as linkedlist where each
node contains info,next part

• Top pointer of the stack represented by start
pointer
• If start =NULL shows stack is empty
• If last node=NULL shows the bottom of the stack

Push operation can be performed in the below steps
Step 1 − Checks stack has some space or stack is full.
Step 2 − If the stack has no space then display “overflow” and exit.
Step 3 − If the stack has space then increase top by 1 to point next empty space.
Step 4 − Adds item to the newly stack location, where top is pointing.
Step 5 – PUSH operation performed successfully.

Step 1 − Checks stack has some element or stack is
empty.
Step 2 − If the stack has no element means it is empty
then display “underflow”
Step 3 − If the stack has element some element,
accesses the data element at which top is pointing.
Step 4 − Decreases the value of top by 1.
Step 5 − POP operation performed successfully.

Queue as a linkedlist
• the array implementation can not be used for the
large scale applications where the queues are
implemented.
• One of the alternative of array implementation is
linked list implementation of queue.
• Size of the queue may increase or decrease according
to the requirement as items get inserted and deleted
• Dynamic representation of queue is called linked
queue
• Linked queue -elements size is not know in advance
may increase

Linked queue :
• In a linked queue, each node of the queue consists of two parts i.e. data part
and the link part.
• Each element of the queue points to its immediate next element in the
memory.
• In the linked queue, there are two pointers maintained in the memory i.e.
front pointer and rear pointer.
• The front pointer contains the address of the starting element of the queue
while the rear pointer contains the address of the last element of the queue.

• Two pointers for front and rear position of the
queue
• front=null (queue is empty)
• front=rear=null

• Accessing the nodes in the forward direction only
• Cannot traverse backward direction
Doubly Linked list
• a node consists of three parts: node data, pointer to
the next node in sequence (next pointer) , pointer to
the previous node (previous pointer).

• Each node contains 1 info field ,2 link pointers (forward &
backward)
• The pointers points to the adjacent to the current node
• Fowrdpointer points to the next node of the current node
• Backward pointer points to the preceding node of the current
node
• 2 Pointers helps in accessing successor and predecessor nodes
of any arbitrary node

Comparison
No Singly linked list Doubly linked list
1. Can move only in forward
direction
Can move both in forward and backward
direction
2. Cannot reach preceding node
fro any arbitrary node
Can reach any preceding node from any
arbitrary node
3. Insertion and deletion to the
preceding node needs
traversal of links again fro the
first node
Insertion and deletion can be easily performed
here bcoz every pointer has links to the
preceding node

Representation of DLL
• static/array/sequential representation
(implementation)
• dynamic/pointer/linked representation
(implementation)

static/array implementation
• DLL is also a collection of similar data items in an array
• Data items of the linkedlist are maintained in the form
of nodes
• Each node contains 3 parts
• Infor
• Prev
• Next

• List of 12 nodes containing integer type of info,prev,next
• In array representation start value =0 and null value =-1
• If any nodes contains -1 shws there is no successor
/predecessor node

• Do not have size limitations
• Use space proportional to the actual number of
elements in the list

DLL Operations
• Same as SLL (singly linkedlist)
• Creation
• Traversal - To access each element of the linked list.
• Insertion - To add/insert a new node to the list.
• Deletion - To remove an existing node from the list.
• Search - To find a node in the list.
• Sort - To sort the nodes.

Insertion into DLL at various positions
• Requires a freenode in which information can be
inserted
• Node can be inserted into DLL and pointers are
adjusted
•

Insert to the end of DLL
Algorithm
○ Step 1: IF PTR = NULL
○ Write OVERFLOW
Go to Step 11
[END OF IF]
○ Step 2: SET NEW_NODE = PTR
○ Step 3: SET PTR = PTR -> NEXT
○ Step 4: SET NEW_NODE -> DATA = VAL
○ Step 5: SET NEW_NODE -> NEXT = NULL
○ Step 6: SET TEMP = START
○ Step 7: Repeat Step 8 while TEMP
-> NEXT != NULL
○ Step 8: SET TEMP = TEMP ->
NEXT
○ [END OF LOOP]Step 9: SET TEMP
-> NEXT = NEW_NODE
○ Step 10C: SET NEW_NODE ->
PREV = TEMP
○ Step 11: EXIT

Insert after in DLL
○ Step 1: IF PTR = NULL
○ Write OVERFLOW
Go to Step 15
[END OF IF]Step 2: SET NEW_NODE =
PTR
○ Step 3: SET PTR = PTR -> NEXT
○ Step 4: SET NEW_NODE -> DATA = VAL
○ Step 5: SET TEMP = START
○ Step 6: SET I = 0
○ Step 7: REPEAT 8 to 10 until I
○ Step 8: SET TEMP = TEMP -> NEXT
○ STEP 9: IF TEMP = NULL
○ STEP 10: WRITE "LESS THAN DESIRED NO. OF
ELEMENTS"
○ GOTO STEP 15
[END OF IF]
[END OF LOOP]Step 11: SET NEW_NODE ->
NEXT = TEMP -> NEXT
○ Step 12: SET NEW_NODE -> PREV = TEMP
○ Step 13 : SET TEMP -> NEXT = NEW_NODE
○ Step 14: SET TEMP -> NEXT -> PREV =
NEW_NODE
○ Step 15: EXIT

Deletion of a node in DLL
• Deletion can be done from the beginning,end, and
at the middle of the list
• Check for the underflow condition (start=NULL)
•

Drawback
• Cannot move directly to the first node after
reaching lastnode of the list

Circular Linked list
• The first and last nodes are linked together
• Next pointer of the last node connects to the first
node instead of containing NULL
• Contains valid addresses without null
• Two types
• Singly circular linked list
• Doubly circular linked list

Singly circular linked list
• the last node of the list contains a pointer to the first
node of the list.
• traverse the circular singly linked list until we reach the
same node where we started.
• The circular singly linked list has no beginning or end.
• No null value is present in the next part of any of the
nodes.

Doubly circular linked list
• has properties of both doubly linked list and circular linked
list
• in which two consecutive elements are linked or connected
by the previous and next pointer and the last node points to
the first node by the next pointer
• also the first node points to the last node by the previous
pointer.

• CLL used to implement circular queue
• Used to maintain the process for execution in the time
sharing OS
• Each process is allotted a timestamp for execution
• Wait for the next turn in a circular queue
• All nodes are connected in the circle so any node can be
accessed from any node

Representation of CLL
• Array representation
• Pointer representation

Array representation
• Data items are maintained in the form of nodes
divided into 3 parts
• 3 parallel arrays of the same sizes
•

Insertion into circular singly linked list at beginning
Step 1: IF PTR = NULL
Write OVERFLOW
Go to Step 11
[END OF IF]
Step 2: SET NEW_NODE = PTR
Step 4: SET NEW_NODE -> DATA = VAL
Step 5: SET TEMP = HEAD
Step 6: Repeat Step 8 while TEMP -> NEXT !=
HEAD
Step 7: SET TEMP = TEMP -> NEXT
[END OF LOOP]
Step 8: SET NEW_NODE -> NEXT = HEAD
Step 9: SET TEMP → NEXT = NEW_NODE
Step 10: SET HEAD = NEW_NODE
Step 11: EXIT

Deletion in circular singly linked list at beginning
Write UNDERFLOW
Go to Step 8
[END OF IF]Step 2: SET PTR = HEAD
Step 3: Repeat Step 4 while PTR → NEXT !=
HEAD
Step 4: SET PTR = PTR → next
[END OF LOOP]
Step 5: SET PTR → NEXT =
HEAD → NEXT
Step 6: FREE HEAD
Step 7: SET HEAD = PTR →
NEXT
Step 8: EXIT

Deleting nodes at given index in the Circular linked list

Step 1 START
Step 2 Store the element to be deleted.
Step 3 Store the position.
Step 4 Initialize counter c=1
Step 5 Check while (c<pos)
Step 6 Count the position of data to be deleted y = x; x = x->link; c++;
Step 7 Use free() to delete y->link = x->link; free(x);
Step 8 STOP

Deletion in Circular singly linked list at the end
Write UNDERFLOW
Go to Step 8
[END OF IF]Step 2: SET PTR = HEAD
Step 3: Repeat Steps 4 and 5 while PTR -> NEXT != HEAD
Step 4: SET PREPTR = PTR
[END OF LOOP]Step 6: SET PREPTR -> NEXT = HEAD
Step 7: FREE PTR
Step 8: EXIT

UNIT-IV
Trees
• Trees: Preliminaries
• Binary Trees
• B-Trees
• Graph
• Graph Terminologies
• Types of Graphs
• Graph Representation
• Hashing
• Hash Functions
● Sorting
● Bubble Sort
● Selection Sort
● Quick Sort
● Heap Sort
● Merge Sort

Tree
• Defined as a finite collection of special data ites called
nodes
• Nodes are arranged in hierarchical order to represent
parent-child relationship
• First node linked with some other nodes in turn linked
with other nodes
• The parent connected to its childrens through edges

Tree is a finite set of data elements called nodes such
that there is a special node called the root of the tree
and the remaining nodes are partitioned into a
number of mutually exclusive subsets which are
themselves trees.The edges that connect the nodes
are called branches , and the number of branches
connected to a particular node is called the degree of
that node .

Binary tree
• Can have maximum two
children
• Left child,right child
• Left child ,right child is also a
subtree

• Binary tree can also be defined as a collection of nodes
• Each node is divided into 3 part containing left child
address,information,right child address

Classification of binary trees
• Complete binary tree
• Almost complete binary tree

Complete binary tree
A complete binary tree is a special type of binary tree
where all the levels of the tree are ﬁlled completely
except the lowest level nodes which are ﬁlled from as
left as possible.

What Is B-tree?
• A B-tree is a data structure that provides sorted data and allows searches,
sequential access, attachments and removals in sorted order.
• The B-tree is highly capable of storing systems that write large blocks of
data.
• The B-tree simplifies the binary search tree by allowing nodes with more
than two children. Below is a B-tree example.

• B-tree stores data such that each node contains
keys in ascending order.
• Each of these keys has two references to another
two child nodes.
• The left side child node keys are less than the
current keys, and the right side child node keys
are more than the current keys.
• If a single node has “n” number of keys, then it
can have maximum “n+1” child nodes.

B-tree
• is a specialized m-way(multiple children) tree that can be widely
used for disk access.
• A B-Tree of order m can have at most m-1 keys and m children.
• using B tree is its capability to store large number of keys in a single
node and large key values by keeping the height of the tree relatively
small.
• A B tree of order m contains all the properties of an M way tree. In
addition, it contains the following properties.
1. Every node in a B-Tree contains at most m children.
2. Every node in a B-Tree except the root node and the leaf
node contain at least m/2 children.
3. The root nodes must have at least 2 nodes.
4. All leaf nodes must be at the same level.

• It is not necessary that, all the nodes contain the same
number of children but, each node must have m/2 number of
nodes.
• A B tree of order 4 is shown in the following image.

Searching
A. Searching in B Trees is similar to that in Binary search tree. For example, if
we search for an item 49 in the following B Tree. The process will something
like following :
i. Compare item 49 with root node 78. since 49 < 78 hence, move to its left sub-tree.
ii. Since, 40<49<56, traverse right sub-tree of 40.
iii. 49>45, move to right. Compare 49.
iv. match found, return.
B. Searching in a B tree depends upon the height of the tree. The search
algorithm takes O(log n) time to search any element in a B tree.

Inserting
Insertions are done at the leaf node level. The following algorithm needs to be followed in order to
insert an item into B Tree.
1. Traverse the B Tree in order to find the appropriate leaf node at which the node can be inserted.
2. If the leaf node contain less than m-1 keys then insert the element in the increasing order.
3. Else, if the leaf node contains m-1 keys, then follow the following steps.
○ Insert the new element in the increasing order of elements.
○ Split the node into the two nodes at the median.
○ Push the median element upto its parent node.
○ If the parent node also contain m-1 number of keys, then split it too by following the same
steps.

Insert the node 8 into the B Tree of order 5 shown in the following image

8 will be inserted to the right of 5, therefore insert 8

The node, now contain 5 keys which is greater than (5 -1 = 4 ) keys.
Therefore split the node from the median i.e. 8 and push it up to its parent
node shown as follows

Deletion
Deletion is also performed at the leaf nodes. The node which is to be deleted can either be a leaf
node or an internal node. Following algorithm needs to be followed in order to delete a node from
a B tree.
1. Locate the leaf node.
2. If there are more than m/2 keys in the leaf node then delete the desired key from the node.
3. If the leaf node doesn't contain m/2 keys then complete the keys by taking the element from
eight or left sibling.
○ If the left sibling contains more than m/2 elements then push its largest element up to its
parent and move the intervening element down to the node where the key is deleted.
○ If the right sibling contains more than m/2 elements then push its smallest element up to
the parent and move intervening element down to the node where the key is deleted.

1. If neither of the sibling contain more than m/2 elements then create a new leaf
node by joining two leaf nodes and the intervening element of the parent node.
2. If parent is left with less than m/2 nodes then, apply the above process on the
parent too.
If the the node which is to be deleted is an internal node, then replace the node with its
in-order successor or predecessor. Since, successor or predecessor will always be on the
leaf node hence, the process will be similar as the node is being deleted from the leaf
node.

Delete the node 53 from the B Tree of order 5 shown in the following
figure.

53 is present in the right child of element 49. Delete it.

Now, 57 is the only element which is left in the node, the minimum number
of elements that must be present in a B tree of order 5, is 2. it is less than
that, the elements in its left and right sub-tree are also not sufficient
therefore, merge it with the left sibling and intervening element of parent i.e.
49.

Types of Graph
• Simple graph
• Multigraph
• Directed graph
• Undirected graph
• Weighted graph
• Regular graph
• Complete graph
• Strongly connected graph
• Weakly connected graph
• Isomorphic graph

Simple graph
Does not contain loop or multiple edges

Weighted graph
• A graph in which the weights are assigned to
each edge

Regular Graph
• A graph in which each vertex has the same degree
‘k’

Strongly connected graph
• Where each vertex is connected to every other
vertex with the direction

Weakly connected graph
• A directed graph is weakly connected if at least two
vertices are not connected

Isomorphic graph
Two graphs in which there is a one to one
correspondence between their vertices and between
their edges

● Are the number of vertices in both graphs the same?
Yes, both graphs have 4 vertices.
● Are the number of edges in both graphs the same?
Yes, both graphs have 4 edges.
● Is the degree sequence in both graphs the same? Yes,
each vertex is of degree 2.
● If the vertices in one graph can form a cycle of length
k, can we find the same cycle length in the other
graph? Yes, each graph has a cycle of length 4.

Graph representation
• Sequential representation using adjacency
matrix
• Linked representation using adjacency list or
linked list of neighbours

Sequential representation using adjacency matrix
• use of an adjacency matrix to represent the mapping between vertices and edges of the graph.
• adjacency matrix can be used to represent the undirected graph, directed graph, weighted directed graph,
and weighted undirected graph.
• If adj[i][j] = w, it means that there is an edge exists from vertex i to vertex j with weight w.
• An entry Aij
in the adjacency matrix representation of an undirected graph G will be 1 if an edge exists
between Vi
and Vj
.
• If an Undirected Graph G consists of n vertices, then the adjacency matrix for that graph is n x n, and the
matrix A = [aij] can be defined as -
• aij
= 1 {if there is a path exists from Vi
to Vj
}
• a = 0 {Otherwise}

Linked representation using adjacency list
•

Hashing
• Hashing is a fundamental data structure that efficiently
stores and retrieves data in a way that allows for quick
access.
• It involves mapping data to a specific index in a hash table
using a hash function, enabling fast retrieval of information
based on its key.
• This method is commonly used in databases, caching
systems, and various programming applications to optimize
search and retrieval operations.
• Avoids number of comparisons
• Goes directly where the required data is present
• Searches in constant time ,no matter where the element is

The process of hashing can be broken down into three steps:
○ Input: The data to be hashed is input into the hashing algorithm.
○ Hash Function: The hashing algorithm takes the input data and
applies a mathematical function to generate a fixed-size hash
value. The hash function should be designed so that different
input values produce different hash values, and small changes in
the input produce large changes in the output.
○ Output: The hash value is returned, which is used as an index to
store or retrieve data in a data structure.

• Provides direct access to records thru hash function
• Hash functions are used in hash tables
• HT uses an array to hold ,or reference,the stored
records
• Most useful in case of large records of data are to
be stored
• Commonly used for symbol table
• HT is used to process the hash value generated by
applying some function on the key
• Determines where to store the record
• Hash function must be chosen so that its return the
value is always a valid index for the array

• When hash function maps to the same
location in the hash table for two different
keys -collision
• Eg ( 0012 ,1112 )%100 =12
• Hash function never provides collision is
called a perfect hash function
• Difficult to find perfect function
• HF Minimizes collision by spreading elements
uniformly throughout the array -good hash
function

Characteristics of a good hash function
• Formed using mathematical transformation
• Should be very easy and quick to compute
• Produce relatively random and unique
distribution of values within the hash table
so that it produces as few collisions as
possible
• Must minimize collisions

Hash functions
• Division method
• Mid square method
• Folding method

Division
•Hash function obtained by using the modulo(mod) operator
•The value is divided by some number M(size of the hash table)
and the remainder is used as the hash address for X
Example
Size of Hash Table (m) = 1000 (0 - 999)
Suppose we want to calculate the index of element x, where x =
123789456
index =123789456 mod 1000
= 456
The element x is stored at position 456 in the hash table.

Mid Square method
•Mid-Square(f
m
) hashing is a hashing technique in which unique
keys are generated.
•a seed value is taken and it is squared.
•Then, some digits from the middle are extracted. These
extracted digits form a number which is taken as the new seed.
•This technique can generate keys with high randomness if a big
enough seed value is taken.
•This process is repeated as many times as a key is required.

Folding method
•The key k is partitioned into a number of parts k
1
, k
2
.... k
n
where each part except possibly the last, has the same
number of digits as the required address.
•Then the parts are added together, ignoring the last carry.
•There are two type of folding:
• ØShift –all are added except least bit
• ØBoundary-Alternate pieces are flipped on the boundary.
Boundary folding is indicated by p_i^r

The task is to fold the key 452378912 into a Hash Table of ten spaces (0
through 9).
● It is given that the key, say X is 452378912 and the table size (i.e., M =
10).
● Since it can break X into three parts in any order. Let’s divide it evenly.
● Therefore, a = 452, b = 378, c = 912.
● Now, H(x) = (a + b + c) mod M i.e., H(452378912) =(452 + 378 + 912)
mod 10 = 1742 mod 10 = 2.
● Hence, 452378912 is inserted into the table at address 2.

Sorting
• Retrieval and searching of data in a particular order
becomes easier
• Sorting is classified into
• Internal sorting and
• External Sorting

Internal Sorting
• Elements to be sorted in main memory
• Where the list of all elements is small
so the sorting can be carried in main
memory

External Sorting
• Elements sorted in secondary memory
• Eg disks and tapes
• Applied to large file of records

Sorting algorithms
• Bubble sort
• Selection sort
• Quick sort
• Heap sort
• Merge sort

Bubble sort
• Easy to understand and implement
• Multiple swapping takes place while
passing through the elements
sequentially
• In each pass compare the element with
its successor and interchange if they are
not in proper order
• Interchange is done bubbling up the
elements
• Process is carried on till it is sorted

Time and Space Complexity
• When bubble sort is used on an array already in ascending
order, it requires only one pass through the entire array.
• This is considered the best-case scenario. In practice, though,
this only occurs sometimes, and bubble sort usually
necessitates n(n-1)/2 swaps or comparisons to achieve a
sorted array.

• In terms of space complexity, since only swapped the
elements with one another and never stored
anything, don’t need any extra space to run the
algorithm.
• This is amazing because it means the space
complexity comes out as constant, or O(1).
• This makes it an in-place algorithm that works by
modifying the input directly.

https://ds1-iiith.vlabs.ac.in/exp/bubble-sort/bubble-sort/bsdemo.html

Selection sort
• Search for the smallest element in the list and
interchange it with the first(0th) position
• This process is repeated for the remaining
unsorted portion until the entire list is sorted.

Time Complexity: The time complexity of Selection Sort is O(N2) as
there are two nested loops:
● One loop to select an element of Array one by one = O(N)
● Another loop to compare that element with every other Array
element = O(N)
● Therefore overall complexity = O(N) * O(N) = O(N*N) = O(N2)

Auxiliary Space: O(1) as the only extra memory used is for
temporary variables while swapping two values in Array.
The selection sort never makes more than O(N) swaps and
can be useful when memory writing is costly.

Quick Sort
• Popular and widely used algorithm
• Developed by CAR Hoare in 1962
• Quickest in average case scenario
• Works on divide and conquer strategy
• Larger problems are divided into sub problems and
finding solutions for the sub problems
• Solutions of the smaller subproblems are combined
to obtain the solution of the whole problem
• Selects a key element called pivot

Divide: In Divide, first pick a pivot element. After that, partition or
rearrange the array into two sub-arrays such that each element in the left
sub-array is less than or equal to the pivot element and each element in
the right sub-array is larger than the pivot element.
Conquer: Recursively, sort two subarrays with Quicksort.

function quickSort(arr):
if length(arr) <= 1:
return arr
else:
pivot = selectPivot(arr) // Choose pivot element
left = [elements in arr less than pivot]
right = [elements in arr greater than pivot]
return concatenate(quickSort(left), pivot,
quickSort(right))

Heap Sort
•Heap is a tree-based data structure in which all the tree nodes are in a
particular order, such that the tree satisfies the heap properties
•Heap sort may be regarded as two stage method
• It is converted to heap with the property that the value of each node is at least
as large as the value of its children nodes .root is the largest key in the tree
• The output sequence is generated in decreasing order by successively
outputting the root and restructuring the remaining tree into a heap
•Follow the given steps to solve the problem:
• Build a max heap from the input data.
• At this point, the maximum element is stored at the root of the heap. Replace it
with the last item of the heap followed by reducing the size of the heap by 1.
Finally, heapify the root of the tree.
• Repeat step 2 while the size of the heap is greater than 1.

Sorting heap by repeatedly deleting the heap

Merge Sort
• External sorting
• Divide and conquer strategy
• that works by dividing an array into smaller
subarrays, sorting each subarray, and then
merging the sorted subarrays back together to
form the final sorted array.

UNIT-V
❖ Algorithm Design Techniques:
➢ Greedy Algorithms
➢ Prim’s Algorithm,
➢ Kruskal’s Algorithm.
❖ Divide and Conquer:
➢ Running Time of Divide and conquer algorithms.
❖ Decrease and Conquer
➢ Depth First Search
➢ Breadth First Search.
❖ Backtracking Algorithms
➢ n Queens Problem
➢ Branch and Bound
➢ Traveling Salesman Problem

Algorithm Design Techniques
What is an algorithm design technique?
An algorithm design technique (or “strategy” or
“paradigm”) is a general approach to solving
problems algorithmically that is applicable to a
variety of problems from different areas of
computing.

• they provide guidance for designing
algorithms for new problems, i.e., problems
for which there is no known satisfactory
algorithm.
• algorithms are the cornerstone of computer
science.
• Algorithm design techniques make it possible
to classify algorithms according to an
underlying design idea

• The classification of algorithms is important for several reasons:
Organization: Algorithms can be very complex and by classifying them, it
becomes easier to organize, understand, and compare different algorithms.
Problem Solving: Different problems require different algorithms, and by
having a classification, it can help identify the best algorithm for a particular
problem.
Performance Comparison: By classifying algorithms, it is possible to compare
their performance in terms of time and space complexity, making it easier to
choose the best algorithm for a particular use case.
Reusability: By classifying algorithms, it becomes easier to re-use existing
algorithms for similar problems, thereby reducing development time and
improving efficiency.
Research: Classifying algorithms is essential for research and development in
computer science, as it helps to identify new algorithms and improve existing
ones.

Classification by Design Method
• Greedy Method: In the greedy method, at each step, a decision is made to choose the local
optimum, without thinking about the future consequences.
• Divide and Conquer: The Divide and Conquer strategy involves dividing the problem into
sub-problem, recursively solving them, and then recombining them for the final answer.
• Dynamic Programming: The approach of Dynamic programming is similar to divide and conquer.
The difference is that whenever we have recursive function calls with the same result, instead of
calling them again we try to store the result in a data structure in the form of a table and retrieve the
results from the table. Thus, the overall time complexity is reduced. “Dynamic” means we
dynamically decide, whether to call a function or retrieve values from the table.
• Linear Programming: In Linear Programming, there are inequalities in terms of inputs and
maximizing or minimizing some linear functions of inputs.

• Reduction(Transform and Conquer): In this method, we solve a difficult problem by transforming it into a
known problem for which we have an optimal solution. Basically, the goal is to find a reducing algorithm
whose complexity is not dominated by the resulting reduced algorithms.
• Backtracking: This technique is very useful in solving combinatorial problems that have a single unique
solution. Where we have to find the correct combination of steps that lead to fulfillment of the task.
Such problems have multiple stages and there are multiple options at each stage. This approach is based
on exploring each available option at every stage one-by-one. While exploring an option if a point is
reached that doesn’t seem to lead to the solution, the program control backtracks one step, and starts
exploring the next option. In this way, the program explores all possible course of actions and finds the
route that leads to the solution.
• Branch and Bound: This technique is very useful in solving combinatorial optimization problem that
have multiple solutions and we are interested in find the most optimum solution. In this approach, the
entire solution space is represented in the form of a state space tree. As the program progresses each
state combination is explored, and the previous solution is replaced by new one if it is not the optimal
than the current solution.

There are two approaches for designing an algorithm. these approaches include
1. Top-Down Approach :
2. Bottom-up approach
● Top-Down Approach: In the top-down approach, a large problem is divided
into small sub-problem. and keep repeating the process of decomposing
problems until the complex problem is solved.
● Bottom-up approach: The bottom-up approach is also known as the reverse
of top-down approaches.In approach different, part of a complex program is
solved using a programming language and then this is combined into a
complete program.

Top-Down Approach:
Breaking down a complex problem into smaller, more manageable
sub-problems and solving each sub-problem individually.
Designing a system starting from the highest level of abstraction and moving
towards the lower levels.
Bottom-Up Approach:
Building a system by starting with the individual components and gradually
integrating them to form a larger system.
Solving sub-problems first and then using the solutions to build up to a solution
of a larger problem.
Note: Both approaches have their own advantages and disadvantages and the
choice between them often depends on the specific problem being solved.

Greedy Algorithms
• to solving a problem that selects the most appropriate option based on the
current situation.
• ignores the fact that the current best result may not bring about the overall
optimal result.
• Even if the initial decision was incorrect, the algorithm never reverses it.
• intuitive algorithm can be applied to solve any optimization problem which
requires the maximum or minimum optimum result.
• easy to understand and implement.

a greedy solution only if the problem statement follows two properties
mentioned below:
● Greedy Choice Property: Choosing the best option at each phase can
lead to a global (overall) optimal solution.
● Optimal Substructure: If an optimal solution to the complete
problem contains the optimal solutions to the subproblems, the
problem has an optimal substructure.

Limitations of Greedy Algorithm
Factors listed below are the limitations of a greedy algorithm:
1. The greedy algorithm makes judgments based on the information at
each iteration without considering the broader problem; hence it
does not produce the best answer for every problem.
2. The problematic part for a greedy algorithm is analyzing its accuracy.
Even with the proper solution, it is difficult to demonstrate why it is
accurate.
3. Optimization problems (Dijkstra’s Algorithm) with negative graph
edges cannot be solved using a greedy algorithm.

• The main disadvantage of using a greedy algorithm
is that it may not find the optimal solution to a
problem.
• In other words, it may not produce the best
possible outcome.
• Additionally, greedy algorithms can be very
sensitive to changes in input data — even a small
change can cause the algorithm to produce a
completely different result.
• Finally, greedy algorithms can be difficult to
implement and understand.

Prim's Algorithm
• used to find the minimum spanning tree from a graph.
• Prim's algorithm finds the subset of edges that includes every vertex
of the graph such that the sum of the weights of the edges can be
minimized.
• Prim's algorithm starts with the single node and explores all the
adjacent nodes with all the connecting edges at every step.
• The edges with the minimal weights causing no cycles in the graph
got selected.

Spanning tree - A spanning tree is the subgraph of
an undirected connected graph.
Minimum Spanning tree - Minimum spanning tree
can be defined as the spanning tree in which the
sum of the weights of the edge is minimum. The
weight of the spanning tree is the sum of the
weights given to the edges of the spanning tree.

The first spanning tree has the least weight i.e. 10 and
hence is the minimum spanning tree.

Kruskal Algorithm
• Another minimum spanning tree problem that also always yields an
optimal solution.
• It is named Kruskal’s algorithm after Joseph Kruskal
• Kruskal’s algorithm looks at a minimum spanning tree of a weighted
connected graph G = ⟨V, E⟩ as an acyclic subgraph with |V | − 1
edges for which the sum of the edge weights is the smallest.
• The algorithm begins by sorting the graph’s edges in nondecreasing
order of their weights.
• Then, starting with the empty subgraph, it scans this sorted
list,adding the next edge on the list to the current subgraph if such
an inclusion does not create a cycle and simply skipping the edge
otherwise.

How does Kruskal's algorithm work?
In Kruskal's algorithm, we start from edges with the lowest weight and keep
adding the edges until the goal is reached. The steps to implement Kruskal's
algorithm are listed as follows -
○ First, sort all the edges from low weight to high.
○ Now, take the edge with the lowest weight and add it to the spanning
tree. If the edge to be added creates a cycle, then reject the edge.
○ Continue to add the edges until we reach all vertices, and a minimum
spanning tree is created.

The applications of Kruskal's algorithm are -
○ Kruskal's algorithm can be used to layout electrical wiring
among cities.
○ It can be used to lay down LAN connections.

Step 5 - After that, pick the edge AE with weight 5. Including this edge will
create the cycle, so discard it.
Step 6 - Pick the edge AC with weight 7. Including this edge will create the
cycle, so discard it.
Step 7 - Pick the edge AD with weight 10. Including this edge will also create
the cycle, so discard it.
So, the final minimum spanning tree obtained from the given weighted graph
by using Kruskal's algorithm is -

○ Time Complexity
The time complexity of Kruskal's algorithm is O(E logE) or
O(V logV), where E is the no. of edges, and V is the no. of
vertices.

Running Time of Divide and conquer algorithms.
• The divide and conquer approach as the name
suggests divides the given problem in parts and then
each problem is solved independently.
• When we keep dividing the problem into smaller
parts a moment comes when the problem cannot
be divided further into smaller part, then those
smaller parts are solved and the solution of all those
smaller parts or sub-parts is finally merged to obtain
the solution of the original problem.

Divide and Conquer Algorithm contains the following
steps:
1. Divide: This involves dividing the problem into smaller sub
problem.
2. Conquer: Solving the smaller sub-problems recursively.
3. Combine: Combine the solutions of the sub-problems that are
part of the recursive process to solve the actual problem.

Advantages of Divide and Conquer:
1. This algorithm makes the given problem easier as it divides the given problem into sub-problems
which makes it easier to solve and then solving each of them individually and combining all the
solution of all sub-problem into one to solve the original problem.
2. The algorithm increases the efficiency of other algorithms such as quick sort, merge sort etc.
These algorithms are the application of Divide and Conquer Algorithm.
3. This algorithm is supported by most of the processors especially with shared memory system
where data communication between processors does not need to be pre-programmed.
4. This algorithm uses memory caches in an efficient manner.

Disadvantages of Divide and Conquer:
1. The main problem which arises with this algorithm is the recursion is slow that increases the
time complexity.
2. Another problem which this algorithm is that sometimes it becomes complicated while
solving the problem through this approach and the basic iterative approach seems more
easier.
3. While solving the problems through this approach sometimes there are same sub-problems.
So its best to save the solution to the repeated sub problem.
4. While using this algorithms, make sure there is enough memory allocated to the return stack;

Divide and Conquer Applications:
• Binary Search
• Merge Sort
• Quick Sort
• Strassen’s Matrix multiplication

Time Complexity
The complexity of the divide and conquer algorithm is calculated
using the master theorem which is as follow.

Decrease and Conquer
make the problem smaller by reducing problem at each
step. They can reduce the problem by
● constant amount
● constant factor
● variable factor

• used to solve problems by reducing the size of the input data at each step of the
solution process.
• This technique is similar to divide-and-conquer, in that it breaks down a problem into
smaller subproblems, but the difference is that in decrease-and-conquer, the size of
the input data is reduced at each step.
• The technique is used when it’s easier to solve a smaller version of the problem, and
the solution to the smaller problem can be used to find the solution to the original
problem.
1. binary search, finding the maximum or minimum element in an array, and finding
the closest pair of points in a set of points.
2. The main advantage of decrease-and-conquer is that it often leads to efficient
algorithms, as the size of the input data is reduced at each step, reducing the time
and space complexity of the solution.

Insertion Sort
To sort an array of size N in ascending order iterate
over the array and compare the current element (key)
to its predecessor, if the key element is smaller than
its predecessor, compare it to the elements before.
Move the greater elements one position up to make
space for the swapped element.

1. defines a function named insertion_sort that takes a single
argument arr, which is expected to be a list.
2. calculates the length of the input list arr and assigns it to
the variable n.
3. initiates a loop that iterates over the indices of the list
arr starting from index 1 up to (but not including) n.
4. selects the current element (key) at index i from the list
arr. This element will be compared and inserted into its
correct position in the sorted sublist.
5. initializes a variable j to the index directly before i. j will
be used to traverse the sorted sublist from right to left
to find the correct position for key.
def insertion_sort(arr):
n = len(arr)
for i in range(1, n):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] >
key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key

1. starts a while loop that continues as
long as j is greater than or equal to 0
(ensuring we don't go out of bounds
of the list) and the element at index j
is greater than the key value. This loop
moves elements of the sorted sublist
greater than key one position to the
right.
2. Within the while loop, these two lines
shift elements of the sorted sublist to
the right to make space for the key
element. j is decremented to continue
traversing the sorted sublist.
3. nce the correct position for key is
found (either at index j+1 or 0 if j
becomes -1), key is inserted into the
sorted sublist at index j+1.
def insertion_sort(arr):
n = len(arr)
for i in range(1, n):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] >
key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key

Breadth First Search
• It is also known as level order traversal.
• The Queue data structure is used for the Breadth First Search
traversal.
• using the BFS algorithm for the traversal in a graph,consider
any node as a root node and explores all the neighboring
nodes.
• Then, it selects the nearest node and explores all the
unexplored nodes.
• While using BFS for traversal, any node in the graph can be
considered as the root node.

• BFS is the most commonly used approach. It is a recursive
algorithm to search all the vertices of a tree or graph data
structure.
• BFS puts every vertex of the graph into two categories - visited
and non-visited.
• It selects a single node in a graph and, after that, visits all the
nodes adjacent to the selected node.
• Breadth-First Search uses a queue data structure to store the node
and mark it as "visited" until it marks all the neighboring vertices
directly related to it.
• The queue operates on the First In First Out (FIFO) principle, so the

How Does the Algorithm Operate?
● Start with the source node.
● Add that node at the front of the queue to the visited list.
● Make a list of the nodes as visited that are close to that
vertex.
● And dequeue the nodes once they are visited.
● Repeat the actions until the queue is empty.

Complexity Of Breadth-First Search Algorithm
• The time complexity of the breadth-first search algorithm can be stated
as O(|V|+|E|) because, in the worst case, it will explore every vertex
and edge.
• The number of vertices in the graph is |V|, while the edges are |E|.
• the space complexity as O(|V|), where |V| is the number of vertices in
the graph, and different data structures are needed to determine which
vertices have already been added to the queue.

BFS applications
• GPS Navigation System
• Broadcasting Network
• Identifying Routes

Depth First Search (DFS)
• It is a recursive algorithm to search all the vertices of a tree data
structure or a graph.
• The depth-first search (DFS) algorithm starts with the initial
node of graph G and goes deeper until we find the goal node or
the node with no children.
• Because of the recursive nature, stack data structure can be
used to implement the DFS algorithm.
• The process of implementing the DFS is similar to the BFS
algorithm

The step by step process to implement the DFS traversal is given as follows -
1. First, create a stack with the total number of vertices in the graph.
2. Now, choose any vertex as the starting point of traversal, and push that vertex
into the stack.
3. After that, push a non-visited vertex (adjacent to the vertex on the top of the
stack) to the top of the stack.
4. Now, repeat steps 3 and 4 until no vertices are left to visit from the vertex on
the stack's top.
5. If no vertex is left, go back and pop a vertex from the stack.
6. Repeat steps 2, 3, and 4 until the stack is empty.

DFS Applications
○ DFS algorithm can be used to implement the topological
sorting.
○ It can be used to find the paths between two vertices.
○ It can also be used to detect cycles in the graph.
○ DFS algorithm is also used for one solution puzzles.

Complexity of Depth-first search algorithm
The time complexity of the DFS algorithm is O(V+E),
where V is the number of vertices and E is the number of
edges in the graph.
The space complexity of the DFS algorithm is O(V).

Backtracking algorithms
• used to solve the problem.
• uses Brute force search to solve the problem,
• to make all the possible solutions and pick out the best
solution from all the desired solutions.
• This rule is also followed in dynamic programming, but
dynamic programming is used for solving optimization
problems.
• In contrast, backtracking is not used in solving optimization
problems.
• Backtracking is used when having multiple solutions, and
require all those solutions.

• It finds a solution by building a solution step by step, increasing levels over time,
using recursive calling.
• A search tree known as the state-space tree is used to find these solutions.
• Each branch in a state-space tree represents a variable, and each level represents a
solution.
• A backtracking algorithm uses the depth-first search method.
• When the algorithm begins to explore the solutions, the abounding function is
applied so that the algorithm can determine whether the proposed solution satisfies
the constraints.
• If it does, it will keep looking. If it does not, the branch is removed, and the algorithm

How Does a Backtracking Algorithm Work?
In any backtracking
algorithm, the algorithm
seeks a path to a feasible
solution that includes some
intermediate checkpoints.
If the checkpoints do not lead
to a viable solution, the
problem can return to the
checkpoints and take another
path to find a solution

Examples
• To Find All Hamiltonian Paths Present in a Graph.
• To Solve the N Queen Problem.
• Maze Solving Problems

To Find All Hamiltonian Paths Present in a Graph.
A Hamiltonian path, also
known as a Hamilton path, is
a graph path connecting two
graph vertices that visit each
vertex exactly once. If a
Hamiltonian way exists with
adjacent endpoints, the
resulting graph cycle is a
Hamiltonian or Hamiltonian
cycle.

To Solve the N Queen Problem
● The problem of placing n queens on the
nxn chessboard so that no two queens
attack each other is known as the
n-queens puzzle.
● Return all distinct solutions to the
n-queens puzzle given an integer n. You
are free to return the answer in any order.
● Each solution has a unique board
configuration for the placement of the
n-queens, where 'Q' and. '' represent a
queen and a space, respectively.

N-Queens problem
• N - Queens problem is to place n - queens in such a manner
on an n x n chessboard that no queens attack each other by
being in the same row, column or diagonal.
• Problem Statement: We need to find out all the possible
arrangements in which N queens can be seated in each row
and each column so that all queens are safe. The queen
moves in 8 directions and can directly attack in these 8
directions only.
• his problem demands us to put 4 queens on 4 X 4 chessboard
in such a way that one queen is present in each row and
column and no queen can attack any other queen directly.
this means no 2 or more queens can be placed in the same
diagonal or row or column.

Let's try to put queens Q1, Q2, Q3, and Q4 in the above
present chessboard. The first queen i.e. Q1 can be put
anywhere on the chessboard as there is no other queen
present on the board and hence no restrictions. Therefore
putting Q1 at position (0,0). So the path so far is| (0,0)|.

When Q1 has been placed there are some places where the next
queens can't be placed to fulfill given conditions. So to put queen Q2
in the second row we have positions - (1,2) and (1,3). Let's put it at
(1,2).The path so far is | (0,0) -> (1,2)|

Now this placement of Q2 blocks all the boxes of row 3 and hence there is no
way to put Q3. If we put it at (2,0) or (2,2), Q1 will attack it, and at (2,1) and
(2,3) Q2 attacks it. Therefore we backtrack from here and revisit the previous
solution by readjusting the position of Q2. So instead of putting it at (1,2), we
put it at (1,3). The path so far is | (0,0) -> (1,3)|

put Q3 at (2,1). Hence, the path so far is | (0,0) -> (1,3) -> (2,1)|.

Now again the same problem occurs, there left no box to place Q4.
There was only 1 way to place Q3 and all placements of Q2 have been
explored, so now we come to Q1 for re-adjustment. We move it from
(0,0) to (0,1). The path so far is | (0,1)|.

put Q2 at (1,0). The path so far is | (0,1) -> (1,0)|.

q3 is put at (2,2). The path so far is | (0,1) -> (1,0) -> (2,2)|.Q

Now again there is no space left for placement of Q4 in row 4. Therefore we
again backtrack and readjust position of Q2 from (1,0) to (1,3).The path so far
is | (0,1) -> (1,3)|.

Q3 is put at (2,0). The path so far is | (0,1) -> (1,0) -> (2,0)|.

put Q4 at (3,2). The path so far is | (0,1) -> (1,0) -> (2,0) -> (3,2)|.

Therefore through backtracking, we reached a solution where 4 queens are
put in each row and column so that no queen is attacking any other on a 4
X 4 chessboard.

N Queen Problem Algorithm
1. create a board of N x N size that stores characters. It will store 'Q' if
the queen has been placed at that position else '.'
2. create a recursive function called "solve" that takes board and
column and all Boards (that stores all the possible arrangements) as
arguments. We will pass the column as 0 so that we can start
exploring the arrangements from column 1.
3. In solve function will go row by row for each column and will check
if that particular cell is safe or not for the placement of the queen,
we will do so with the help of isSafe() function.
4. For each possible cell where the queen is going to be placed, will
first check isSafe() function.

5. If the cell is safe, we put 'Q' in that row and column of the board
and again call the solve function by incrementing the column by 1.
6. Whenever we reach a position where the column becomes
equal to board length, this implies that all the columns and possible
arrangements have been explored, and so we return.
7. Coming on to the boolean isSafe() function, we check if a queen
is already present in that row/ column/upper left diagonal/lower
left diagonal/upper right diagonal /lower right diagonal. If the
queen is present in any of the directions, we return false. Else we
put board[row][col] = 'Q' and return true.

Branch and Bound
• is one of the techniques used for problem solving.
• It is similar to the backtracking since it also uses
the state space tree.
• It is used for solving the optimization problems
and minimization problems.
• given a maximization problem then can convert it
using the Branch and bound technique by simply
converting the problem into a maximization
problem.

• Branch and bound algorithms are used to find the optimal
solution for combinatory, discrete, and general
mathematical optimization problems.
• the branch and bound algorithm extends all the paths it can
follow. That means it visits all the nodes and all the paths to
generate the shortest distance.

Travelling Salesman Problem
given-
● A set of some cities
● Distance between every pair of cities
Travelling Salesman Problem states-
● A salesman has to visit every city exactly once.
● He has to come back to the city from where he starts his journey.
● What is the shortest possible route that the salesman must follow to complete his tour?

Example:
Consider a salesman who needs to visit 4 cities: A, B, C, and D. The distances
between these cities are as follows:
● A to B: 10 units
● A to C: 15 units
● A to D: 20 units
● B to C: 35 units
● B to D: 25 units
● C to D: 30 units
The goal is to find the shortest route that visits each city exactly once and returns
to the starting point.

Steps to Solve TSP:
• Generate Permutations: Generate all possible permutations of
the cities. Each permutation represents a possible route that
the salesman can take.
• Calculate Route Lengths: Calculate the total distance for each
permutation. Add up the distances between consecutive cities
in the permutation and add the distance from the last city back
to the starting city.
• Find the Shortest Route: Identify the permutation with the
shortest total distance. This represents the optimal route for
the salesman.

Applying Steps to the Example:
Generate Permutations:
● Possible permutations: ABCD, ABDC, ACBD, ACDB, ..., DCBA
● There are 4! = 24 possible permutations in total.
Calculate Route Lengths:
● For each permutation, calculate the total distance.
● For example, for the permutation ABCD, the total distance = 10 + 15 + 20 +
30 + 10 = 85 units.
Find the Shortest Route:
● Compare the total distances calculated for each permutation.
● Identify the permutation with the shortest total distance. This represents
the shortest route.

DATA STRUCTURE AND ALGORITHM for beginners

More Related Content

What's hot

Similar to DATA STRUCTURE AND ALGORITHM for beginners

More from Sabitha Banu

Recently uploaded

DATA STRUCTURE AND ALGORITHM for beginners