SYLLABUS

Introduction: FromProblem to Program (Problem, Solution,

Algorithm, Data Structure and Program).
Data Structures: Data, Information, Knowledge, and Data
structure, Abstract Data Types (ADT), Data Structure
Classification (Linear and Non-linear, structures)
Static and Dynamic, Persistent and Ephemeral data
Algorithms: Problem Solving, Introduction to algorithm,
Characteristics of algorithm, Algorithm design tools: Pseudo-code and
flowchart.
Complexity of algorithm: Space complexity, Time complexity,
Asymptotic notation- Big-O, Theta and Omega, finding complexity
using step count method, Analysis of programming constructs-Linear,
Quadratic, Cubic, Logarithmic.
Algorithmic Strategies: Introduction to algorithm design strategies-
Divide and Conquer, and Greedy strategy.
INTRODUCTION
 Introduction
Computer : A programmable device that can store, retrieve,
and process data.(Combination of H/w & S/w )

Hardware : things which we can touch.

Software : things which we cannt touch.(Can only see)

Programming: A programming language is a set of
commands, instructions, and other syntax use to create a
software program.

Data : Information in a form a computer can use

Information : Any knowledge that can be communicated
 Introduction
Data type : The specification of how information is represented
in the computer as data and the set of operations that can be
applied to it Computer

Computer program : Data type specifications and instructions

for carrying out operations that are used by a computer to solve a
problem
 Introduction
Machine language : The language, made up of
binarycoded instructions, that is used directly by the
computer

Assembly language : A low-level programming language

in which a mnemonic is used to represent each of the
machine language instructions for a particular computer

Assembler : A program that translates an assembly

language program into machine code
 Introduction
Compiler : A program that translates a program written
in a high-level language into machine code

Source code : Data type specifications and instructions

written in a high-level programming language

Object code : A machine language version

of source code.
 DATA
STRUCTURE
 DATA STRUCTURE
Data Structure is a way to store and
organize data so that it can be used efficiently.

Data :
“Data is nothing but collection of information i.e.
facts or figures.”

Data Object :
“Data object is a region of storage
contains a value or group of value” that
 NEED OF DATA STRUCTURE
• Stores huge data

• Stores data in systematic way

• Retains logical relationship

• Provides various structure

• Static and dynamic formats

• Better algorithms
 ABSTRACT DATA TYPE
ADT :
“Abstract data types are mathematical models of a set of
data values or information that share similar behavior or qualities and that
can be specified and identified independent of specific implementations.
Abstract data types, or ADTs, are typically used in algorithms.”

Another definition of ADT

is ADT is set of D, F and A.

D – domain = Data object

F – function = set of operation which cannt carried out on data object.
A – axioms = Properties and rule of the operation
 TYPESOF DATA STRUCTURE
There are two types :
1. Primitives data structure
2. Non-primitive data structure
 TYPESOF DATA STRUCTURE
1. Primitives data structure :

“Primitive data structures are those which are predefined

way of storing data by the system. ”

e.g. int, char, float etc

2. Non-primitive data structure :

“The data types that are derived from primary data types are known
as non-Primitive data types. These datatype are used to store group of
values.”

e.g. struct, array, linklist, stack, tree , graph etc.

 Linear and Non-Linear
Data Structure
1. Linear Data Strucute :
“Linear data structuretraverses the data elements
sequentially, in which only one data element can directly be
reached”
Ex: Arrays, Linked Lists, stack, queue.

2. Non-Linear Data Strucute :

“Every data item is attached to several other data items in a
way that is specific for reflecting relationships.”
Ex: Graph , Tree
Linear vs Non-Linear Data
Structure
Static and Dynamic Data Structure
1. Static data strucure :
“A static data structureis an organization or
collection of data in memory that is fixed in size.”
Ex: Arrays

2. Dynamic Data Strucute :

“ In Dynamic data structure the size of the structure in not
fixed and can be modified during the operations performed on it”
Ex: Linked list
 Persistent andEphemeral
Data Structure
1. Persistent data strucure :
“A persistent data structure is a data structure that
always preserves the previous version of itself when it is
modified..”
Ex: Linked list, tree
2. Ephemeral Data Strucute :
“ An ephemeral data structure is one of which only one
version is available at a time(it does not preserve previous
version).”
Ex: RAM , Cache memory
Relationship among Data,
Data Structure and
Algorithms
Data is considered as set of facts and figures or data is value of
group of value which is in particular format.
Data structure is method of gathering as well as organizing data
in such manner that several operation can be performed

Problem is defined as a situation or condition which

need to solve to achieve the goals

Algorithm is set of ordered instruction which

are written in simple english language.
ALGORITHM
 ALGORITHM –PROBLEM SOLVING
COMPUTER :
“Computer is multi purpose Electronic Machine which is
used for storing , organizing and processing data by set of
program

Problem :
“Problem is defined as situation or condition which needs
to solve to achive goal”

Steps in Problem Solving :

1. Define the problem
2. Data gathering
3. Decide effective solution
4. Implement and evaluate the solution
5. Review the result.
 PROBLEM SOLVING
TECHNIQUES
There are two types :
1. Algorithmic
2. Flowchart
Algorithms is set of instructions which are writeen in simple
english language.
Flowchart is graphical representation of the algorithms.
 Some other Problem Solving
Techniques

1. Trial and error techniques

1. Divide and conquer techniques

1. Merging solution

1. The building block approach

1. Brain storming techniques

 INTRODUCTION OF ALGORITHMS
DEFINITION :
“An algorithm is defined as a step-by-step procedure or method for
solving a problem by a computer in a finite number of steps.”

From the data structure point of view, following are some important
categories of algorithms −

Search − Algorithm to search an item in a data structure.

Sort − Algorithm to sort items in a certain order.

Insert − Algorithm to insert item in a data structure.

Update − Algorithm to update an existing item in a data structure.

Delete − Algorithm to delete an existing item from a data structure.

 CHARACTRISTICS OF
ALGORITHM
1.Unambiguous − Algorithm should be clear and unambiguous. Each of
its steps (or phases), and their inputs/outputs should be clear and must
lead to only one meaning.

2. Input − An algorithm should have 0 or more well-defined inputs.

3.Output − An algorithm should have 1 or more well-defined outputs,
and should match the desired output.

4. Finiteness − Algorithms must terminate after a finite number of steps.

5. Feasibility − Should be feasible with the available resources.
6.Independent − An algorithm should have step-by-step directions,

which should be independent of any programming code.

 EXAMPLE OFALGORITHM
Example
Let's try to learn algorithm-writing by using an example.
Problem − Design an algorithm to add two numbers and display the result.

Step 1 − START

Step 2 − declare three integers a, b &c

Step 3 − define values of a & b

Step 4 − add values of a & b

Step 5 − store output of step 4 toc

Step 6 − print c
ALGORITHM DESIGN TOOL
• There can be two tools :
1. Flowchart
2. Pseudo Code

Flowchart :
“ Flowchart is graphical representation of the algorithms”

Pseudo Code :
“It is simply an implementation of an algorithm in the form of
annotations and informative text written in plain English.

Prof. Anand Gharu

 FLOWCHAR
T
Symbol used in Flowchart :
EXAMPLE OF
FLOWCHART
 EXAMPLE FOR ALGORITH &
FLOWCHART
Step1: Start
Step2: Initialize the count variable to zero
Step3: Initialize the sum variable to zero
Step4: Read a number say x
Step 5: Add 1 to the number in the count
variable Step6: Add the number x to the sum
variable.
Step7: Is the count variable in the memory greater than If

50? If yes, display the sum: go to step 8. No,

Repeat from step 4
Design an algorithm and flowchart to input
fifty numbers and calculate their sum.
WRITE A PROGRAM FOR ADDING 10 NUMBERS
WRITE A PROGRAM TO FIND FACTORIAL
OF NUMBER
DIFFERENT APPROCHES TO DESIGN ALGORITHMS
Types of approach :
1. Top down approach
2. Bottom up approach
TOP DOWN APPROACH BOTTOM UP APPROACH

1. Larger problem divided into smaller Smaller pieces are combined together

2. Execution Start from top to down Execution start from bottom to top

3. C is top down approach language C++ is bottom up approach language

4. Main() is written at beginning Main() is written at end of program

Complexity of
Algorithms
ALGORITHM
ANALYSIS
• A Priori Analysis − This is a theoretical analysis of an algorithm.
Efficiency of an algorithm is measured by assuming that all other
factors, for example, processor speed, are constant and have no
effect on the implementation.

• A Posterior Analysis This is an empirical analysis

−
algorithm. of an is implemented using
The selected algorithm
programming language. This is then executed on target computer
machine. In this analysis, actual statistics like running time and space
required, are collected.

Prof. Anand Gharu

 CASES OF ANALYSISALGORITHMS
There are 3 types.
1. Worst case
2. Best case
3. Average
case

Best Case − Minimum time required for program execution.

Average Case − Average time required for program

execution.

Worst Case − Maximum time required for program execution

 Standard measure of efficiency
There are two important complexity measures:
1. Time complexity
2. Space complexity

Time complexity :
“The time which is required for analysis of given problem
of particular size is known as time complexity”

Space complexity :
“The amount of computer memory required tp solve the
given problem of particular size is called as space complexity”

Time efficiency - a measure of amount of time for an algorithm to execute.

Space efficiency - a measure of the amount of memory needed for an algorithm to

 Asymptotic notations
Asymptotic Notations are languages that allow us to
analyze an algorithm's running time by identifying its
behavior as the input size for the algorithm increases. This is
also known as an algorithm's growth rate

Asymptotic Notation gives us the ability to

answer these questions.

Following are the commonly used asymptotic notations

to calculate the running time complexity of an
algorithm.
1. Ο Notation
2. Ω Notation
 BIG – oh
Big Oh Notation, Ο
The NOTATION
notation Ο(n) is the formal way to express the upper
bound of an algorithm's running time. It measures the worst
case time complexity or the longest amount of time an
algorithm can possibly take to complete.
 Omega
Omega Notation, Ω
NOTATION
The notation Ω(n) is the formal way to express the lower
bound of an algorithm's running time. It measures the best
case time complexity or the best amount of time an
algorithm can possibly take to comp
 Theta
Theta Notation, θ
NOTATION
The notation θ(n) is the formal way to express both the
lower bound and the upper bound of an algorithm's running
time. It is represented as follows −
Common Asymptotic Notation
Analysis of Programming Construct
Algorithmic
Strategies
ALGORITHMIC STRATEGIES
Algorithm design strategies are the general approaches
used to develop efficient solution to problem.
Algorithmic strategies are also called as algorithmic techniques or
algorithmic paradigm.
Algorithm Strategies are :
1. Divide and conquer

2. Greedy Algorithms

3. Brute-force

4. Backtracking
 DIVIDE AND CONQUER
In divide and conquer approach, a given problem is divided into
smaller sub-problems and then each problem is solved independently.
When we keep on dividing the subproblems into even smaller sub-
problems, we may eventually reach a stage where no more division is
possible. Those "atomic" smallest possible sub-problem (fractions) are
solved. The solution of all sub-problems is finally merged in order to
obtain the solution of an original problem.
 DIVIDE AND CONQUER
Operation for strategy :
Divide – Break the problem into subproblem of same type
Conquer – Recursively solve these sub problem
Combine – Combine the solution of sub problem

Following algorithms are based on divide and conquer

Following
strategies :
1. Merge sort
2. Binary search
3. Tower of Hanoi
4. Quick sort
5. Closest pair
 DIVIDE AND CONQUER
1. Merge sort :
Merge Sort is a Divide and Conquer algorithm. It divides input array in
two halves, calls itself for the two halves and then merges the two sorted
halves. The merge() function is used for merging two halves. The
merge(arr, l, m, r) is key process that assumes that arr[l..m] and
arr[m+1..r] are sorted and merges the two sorted sub-arrays into one.
1. Divide the unsorted list into two sub lists of
about half the size.
2. Conquer: Sort each of the two sub lists
recursively until we have list sizes of length
1,in which case the list itself is returned.
3. Combine: Merge the two-sorted sub lists back
into one sorted list.
⦿ MERGE SORT (A,p,r)
//divide if p < r
then q= [ (p + r) / 2 ]
MERGE SORT(A,p,q)
MERGER SORT(A,q + 1,r)
MERGE(A,p,q,r)
99 6 86 15 58 35 86 4 0
 99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0
 99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0
 99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0
 99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

4 0
 99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

99 6 86 15 58 35 86 4 0

4 0
99 6 86 15 58 35 86 0 4

Merge
4 0
 6 99 15 86 35 58 0 4 86

99 6 86 15 58 35 86 0 4

Merge
 6 15 86 99 0 4 35 58 86

6 99 15 86 58 35 0 4 86

Merge
 0 4 6 15 35 58 86 86 99

6 15 86 99 0 4 35 58 86

Merge
Binary search
Introduction:
The Binary Search can be implemented only on
sorted
□ list of elements.

□
The process starts with finding the element at the middle
of the list and comparing the key value with the element
in the middle of the list, if the value of the key is less
than the element at the middle then the search process
the key to the list up to the middle element and if the
value of the key is greater than element at the middle
then search the key from middle element to the end of
the list.
 Binary search, also known as half-interval search
or logarithmic search, is a search algorithm that
finds the position of a target value within a sorted
array.
Binary search:
Time Analysis
Best case - O (1) comparisons : In the best case, the
□item X is the middle in the array A. A constant number
of comparisons (actually just 1) are required.

Worst case - O (log n) comparisons : In the worst

case, the item X does not exist in the array A at all.
□
Through each recursion or iteration of Binary Search,
the size of the admissible range is halved. This halving
can be done ceiling(log n ) times. Thus, ceiling(log n )
comparisons are required.
Time Analysis
Average case - The average cost of a successful
□
search is about the same as the worst case where an
item is not found in the array, both being roughly
equal to logN. So, the average and the worst case
cost of binary search, in big-O notation, is O(logN).
Advantage and Disadvantage
□ Advantage:
1. Binary search is an optimal searching algorithm using
which we can search desired element very efficiently.

□ Disadvantage:
1. This algorithm requires the list to be sorted . Then
only this method is applicable.
 Application

1. The binary search is an efficient searching method and

is used to search desired record from database.
 DIVIDE AND CONQUER
2. Tower of Hanoi :

Tower of Hanoi is a mathematical puzzle where we have three rods and n

disks. The objective of the puzzle is to move the entire stack to another

rod, obeying the following simple rules:

1) Only one disk can be moved at a time.

2)Each move consists of taking the upper disk from one of the stacks and

placing it on top of another stack i.e. a disk can only be moved if it is the

uppermost disk on a stack.

1) No disk may be placed on top of a smaller disk.

 DIVIDE AND CONQUER
2. Tower of Hanoi : Example
 GREEDYSTRATEGIES
Greedy algorithm :
An algorithm is designed to achieve optimum solution for a given
problem. In greedy algorithm approach, decisions are made from the
given solution domain. As being greedy, the closest solution that seems
to provide an optimum solution is chosen.

Example of greedy strategy :

1. Travelling Salesman Problem
2. Prim's Minimal Spanning Tree Algorithm
3. Kruskal's Minimal Spanning Tree Algorithm
4. Dijkstra's Minimal Spanning Tree Algorithm
5. Knapsack Problem
6. Job Scheduling Problem
 GREEDYSTRATEGIES
1. Minimum Spanning tree (Prims or Kruskal’s algorithms)
The cost of the spanning tree is the sum of the weights of all the edges
in the tree. There can be many spanning trees. Minimum spanning tree is
the spanning tree where the cost is minimum among all the spanning
trees. There also can be many minimum spanning trees.
 GREEDYSTRATEGIES
1. Kruskal’s algorithms :
Kruskal’s Algorithm builds the spanning tree by adding edges one by
one into a growing spanning tree. Kruskal's algorithm follows greedy
approach as in each iteration it finds an edge which has least weight and
add it to the growing spanning tree.

Algorithm Steps :

Sort the graph edges with respect to their weights.

Start adding edges to the MST from the edge with the
smallest weight until the edge of the largest weight.

Only add edges which doesn't form a cycle .

 GREEDYSTRATEGIES
2. Kruskal’s algorithms : Example

.
 GREEDYSTRATEGIES
2. Kruskal’s algorithms : Example

.
 GREEDYSTRATEGIES
2. Prims algorithm: Prim’s Algorithm also use Greedy approach to find
the minimum spanning tree. In Prim’s Algorithm we grow the spanning
tree from a starting position. Unlike an edge in Kruskal's, we add
vertex to the growing spanning tree in Prim's.

Algorithm Steps:

1. Initialize the minimum spanning tree with a vertex chosen at random.

2.Find all the edges that connect the tree to new vertices, find the minimum
and add it to the tree.

1. Keep repeating step 2 until we get a minimum spanning tree.

Prims algorithm: Example
 GREEDYSTRATEGIES
2. Prims algorithm: Example
Questions on Unit-I
THANK YOU!!!