Lecture Notes

Design and Analysis of Algorithms

VTU-18CS42

Prepared by

DR. HARIVINOD N
Associate Professor,
Dept. of Computer Science and Engineering,
SJEC Mangaluru

Course website:

www.harivinod.in
 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

Module-1: Introduction

Contents

1. Introduction 4. Important Problem Types

1.1. What is an Algorithm? 4.1. Sorting
1.2. Algorithm Specification 4.2. Searching
1.3. Analysis Framework 4.3. String processing
2. Performance Analysis 4.4. Graph Problems
2.1. Space complexity 4.5. Combinatorial Problems
2.2. Time complexity 5. Fundamental Data Structures
2.3. Time Space trade off 5.1. Linear Data Structures
3. Asymptotic Notations 5.2. Graphs
3.1. Big-Oh notation 5.3. Trees
3.2. Omega notation 5.4. Sets and Dictionaries.
3.3. Theta notation
3.4. Little-oh notation
3.5. Mathematical analysis

1.1 Introduction
1.1.1 What is an Algorithm?
Algorithm: An algorithm is a finite sequence of unambiguous instructions to solve a particular
problem.
 Input. Zero or more quantities are externally supplied.
 Output. At least one quantity is produced.
 Definiteness. Each instruction is clear and unambiguous. It must be perfectly clear what
should be done.
 Finiteness. If we trace out the instruction of an algorithm, then for all cases, the algorithm
terminates after a finite number of steps.
 Effectiveness. Every instruction must be very basic so that it can be carried out, in
principle, by a person using only pencil and paper. It is not enough that each operation be
definite as in criterion c; it also must be feasible.
1.1.2. Algorithm Specification
An algorithm can be specified in
1) Simple English
2) Graphical representation like flow chart
3) Programming language like c++/java
4) Combination of above methods.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.2

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

1.1.3. Analysis Framework

Measuring an Input’s Size
Almost all algorithms run longer on larger inputs. For example, it takes longer to sort larger
arrays, multiply larger matrices, and so on. Therefore, we investigate an algorithm's efficiency
as a function of some parameter n indicating the algorithm's input size.
There are situations, where the choice of a parameter indicating an input size does matter.
For example, how should we measure an input's size for a spell-checking algorithm? If the
algorithm examines individual characters of its input, then we should measure the size by the
number of characters; if it works by processing words, we should count their number in the
input.
We should make a special note about measuring the size of inputs for algorithms involving
properties of numbers (e.g., checking whether a given integer n is prime). For such
algorithms, computer scientists prefer measuring size by the number b of bits in the n's binary
representation:𝑏 = ⌊log 2 n ⌋ + 1. This metric usually gives a better idea about the efficiency
of algorithms in question.

Units for Measuring Running lime

To measure an algorithm's efficiency, we would like to have a metric that does not depend
on these extraneous factors. One possible approach is to count the number of times each of
the algorithm's operations is executed. This approach is both excessively difficult and, as we
shall see, usually unnecessary. The thing to do is to identify the most important operation of
the algorithm, called the basic operation, the operation contributing the most to the total
running time, and compute the number of times the basic operation is executed.
For example, most sorting algorithms work by comparing elements (keys) of a list being
sorted with each other; for such algorithms, the basic operation is a key comparison.
As another example, algorithms for matrix multiplication and polynomial evaluation require
two arithmetic operations: multiplication and addition.
Let cop be the execution time of an algorithm's basic operation on a particular computer, and
let C(n) be the number of times this operation needs to be executed for this algorithm. Then we
can estimate the running time T(n) of a program implementing this algorithm on that computer
by the formula: 𝑻(𝒏) ≈ 𝒄𝒐𝒑 𝑪(𝒏)

Unless n is extremely large or very small, the formula can give a reasonable estimate of the
algorithm's running time. It is for these reasons that the efficiency analysis framework ignores
1multiplicative constants and concentrates on the count's order of growth to within a constant
multiple for large-size inputs.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.3

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

Orders of Growth
Why this emphasis on the count's order of growth for large input sizes? Because for large values
of n, it is the function's order of growth that counts: just look at table which contains values of
a few functions particularly important for analysis of algorithms.
Table: Values of several functions important for analysis of algorithms

Algorithms that require an exponential number of operations are practical for solving only
problems of very small sizes.

1.2. Performance Analysis

There are two kinds of efficiency: time efficiency and space efficiency.
 Space efficiency deals with the extra space the algorithm requires
 Time efficiency indicates how fast an algorithm runs
1.2.1 Space complexity
Total amount of computer memory required by an algorithm to complete its execution is called
as space complexity of that algorithm. The Space required by an algorithm is the sum of
following components
 A fixed part that is independent of the input and output. This includes memory space
for codes, variables, constants and so on.
 A variable part that depends on the input, output and recursion stack. ( We call these
parameters as instance characteristics)
Space requirement S(P) of an algorithm P, S(P) = c + Sp where c is a constant depends on the
fixed part, Sp is the instance characteristics.
Example-1: Consider following algorithm abc()

Here fixed component depends on the size of a, b and c. Also instance characteristics Sp = 0
Example-2: Let us consider the algorithm to find sum of array. For the algorithm given here
the problem instances are characterized by n, the number of elements to be summed. The space
needed by a[ ] depends on n. So the space complexity can be written as; Ssum(n) ≥ (n+3); n for
a[ ], One each for n, i and s.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.4

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

1.2.2 Time complexity

The execution time or run-time of the program is refereed as its time complexity denoted by tp
(instance characteristics). This is the sum of the time taken to execute all instructions in the
program. Exact estimation runtime is a complex task, as the number of instructions executed
is dependent on the input data. Also, different instructions will take different time to execute.
So, for the estimation of the time complexity, we count only the number of program steps.
We can determine the steps needed by a program to solve a particular problem instance in
two ways.
Method-1: We introduce a new variable count to the program which is initialized to zero. We
also introduce statements to increment count by an appropriate amount into the program. So
when each time original program executes, the count also incremented by the step count.
Example: Consider the algorithm sum(). After the introduction of the count the program will
be as follows. We can estimate that invocation of sum() executes total number of 2n+3 steps.

Method-2: Determine the step count of an algorithm by building a table in which we list the
total number of steps contributed by each statement.
Example: An example is shown below. The code will find the sum of n numbers.

Example: Matrix addition

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.5

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

The above method is both excessively difficult and, usually unnecessary. The thing to do is to
identify the most important operation of the algorithm, called the basic operation, the
operation contributing the most to the total running time, and compute the number of times the
basic operation is executed.
1.2.3 Time-Space tradeoff
There is often a time-space-tradeoff involved in a problem, that is, it cannot be solved with
few computing time and low memory consumption. One has to make a compromise and to
exchange computing time for memory consumption or vice versa, depending on which
algorithm one chooses and how one parameterizes it.

1.3. Asymptotic Notations

The efficiency analysis framework concentrates on the order of growth of an algorithm’s basic
operation count as the principal indicator of the algorithm’s efficiency. To compare and rank
such orders of growth, computer scientists use three notations:O(big oh), Ω(big omega), Θ
(big theta) and o(little oh)
1.3.1. Big-Oh notation
Definition: A function t(n) is said to be in O(g(n)),
denoted t(n) ∈ O(g(n)), if t(n) is bounded above by
some constant multiple of g(n) for all large n, i.e.,
if there exist some positive constant c and some
nonnegative integer n0 such that
t(n) ≤ cg(n) for all n ≥ n0.

Informally, O(g(n)) is the set of all functions with a lower or same order of growth as g(n).
Note that the definition gives us a lot of freedom in choosing specific valuesfor constants c and
n0.
1
Examples: 𝑛 𝜖 𝑂(𝑛2 ), 100𝑛 + 5 𝜖 𝑂(𝑛2 ), 𝑛(𝑛 − 1)𝜖𝑂(𝑛2 )
2

𝑛3 ∉ 𝑂(𝑛2 ), 0.00001𝑛3 ∉ 𝑂(𝑛2 ), 𝑛4 + 𝑛 + 1 ∉ 𝑂(𝑛2 )

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.6

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

Strategies to prove Big-O: Sometimes the easiest way to prove that f(n) = O(g(n)) is to take c
to be the sum of the positive coefficients of f(n). We can usually ignore the negative
coefficients.

Example: To prove 100n + 5 ∈ O(n2)

100n + 5 ≤ 105n2. (c=105, n0=1)
Example: To prove n2 + n = O(n3)
Take c = 1+1=2, if n ≥n0=1, then n2 + n =
O(n3)
Exercise i) Prove 3n+2=O(n) ii) Prove 1000n2+100n-6 = O(n2)

1.3.2. Omega notation

Definition: A function t(n) is said to be in Ω(g(n)),
denoted t(n)∈ Ω(g(n)), if t(n) is bounded below by
some positive constant multiple of g(n) for all large
n,i.e., if there exist some positive constant c and
some nonnegative integer n0 suchthatt(n) ≥ c g(n)
for all n ≥ n0.

Here is an example of the formal proof that n3 ∈ Ω(n2) : n3 ≥ n2 for all n ≥ 0, i.e., we can
select c = 1 and n0 = 0.

Example:

Example: To prove n3 + 4n2 = Ω(n2)

We see that, if n≥0, n3+4n2≥ n3≥ n2; Therefore n3+4n2 ≥ 1n2for alln≥0
Thus, we have shown that n3+4n2 =Ω(n2) where c = 1 & n0=0

1.3.3. Theta notation

A function t(n) is said to be in Θ(g(n)), denoted t(n)
∈ Θ(g(n)), if t (n) is bounded both above and below
by some positive constant multiples ofg(n) for all
large n, i.e., if there exist some positive constants
c1 and c2 and somenonnegative integer n0 such that
c2g(n) ≤ t(n) ≤ c1g(n) for all n ≥ n0.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.7

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

Example: n2 + 5n + 7 = Θ(n2)

Strategies for Ω and Θ

 Proving that a f(n) = Ω(g(n)) often requires more thought.
– Quite often, we have to pick c < 1.
– A good strategy is to pick a value of c which you think will work, and determine
which value of n0 is needed.
– Being able to do a little algebra helps.
– We can sometimes simplify by ignoring terms of f(n) with the positive coefficients.
 The following theorem shows us that proving f(n) = Θ(g(n)) is nothing new:
Theorem: f(n) = Θ(g(n)) if and only iff(n) = O(g(n)) and f(n) = Ω(g(n)).
Thus, we just apply the previous two strategies.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.8

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

Theorem: If t1(n) ∈ O(g1(n)) and t2(n) ∈ O(g2(n)), then t1(n) + t2(n) ∈ O(max{g1(n), g2(n)}).
(The analogous assertions are true for the Ω and Ө notations as well.)
Proof: The proof extends to orders of growth the following simple fact about four arbitrary
real numbers a1, b1, a2, b2: if a1 ≤ b1 and a2 ≤ b2, then a1 + a2 ≤ 2 max{b1, b2}.
Since t1(n) ∈ O(g1(n)), there exist some positive constant c1 and some nonnegative integer n1
such that t1(n) ≤ c1g1(n) for all n ≥ n1.
Similarly, since t2(n) ∈ O(g2(n)), t2(n) ≤ c2g2(n) for all n ≥ n2.
Let us denote c3 = max{c1, c2} and consider n ≥ max{n1, n2} so that we can use both
inequalities. Adding them yields the following:
t1(n) + t2(n) ≤ c1g1(n) + c2g2(n)
≤ c3 g1(n) + c3g2(n) = c3[g1(n) + g2(n)]
≤ c32 max{g1(n), g2(n)}.
Hence, t1(n) + t2(n) ∈ O(max{g1(n), g2(n)}), with the constants c and n0 required by the O
definition being 2c3 = 2 max{c1, c2} and max{n1, n2}, respectively.

3.4. Little Oh
The function f(n)= o(g(n)) [ i.e f of n is a little oh of g of n ] if and only if
𝑓(𝑛)
lim =0
𝑛→∞ 𝑔(𝑛)

Example:

For comparing the order of growth limit is used

If the case-1 holds good in the above limit, we represent it by little-oh.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.9

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

1.3.5. Basic asymptotic efficiency Classes

Class Name Comments

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.10

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

1.3.6. Mathematical Analysis of Non-recursive & Recursive Algorithms

Analysis of Non-recursive Algorithms
General Plan for Analyzing the Time Efficiency of Nonrecursive Algorithms
1. Decide on a parameter (or parameters) indicating an input’s size.
2. Identify the algorithm’s basic operation. (As a rule, it is located in innermost loop.)
3. Check whether the number of times the basic operation is executed depends only on the
size of an input. If it also depends on some additional property, the worst-case, average-
case, and, if necessary, best-case efficiencies have to be investigated separately.
4. Set up a sum expressing the number of times the algorithm’s basic operation is
executed.
5. Using standard formulas and rules of sum manipulation, either find a closedform
formula for the count or, at the very least, establish its order of growth.
Example-1: To find maximum element in the given array

Here comparison is the basic operation. Note that number of comparisions will be same for all
arrays of size n. Therefore, no need to distinguish worst, best and average cases. Total number
of basic operations (comparison) are,

Example-2: To check whether all the elements in the given array are distinct

Here basic operation is comparison. The maximum no. of comparisons happen in the worst
case. (i.e. all the elements in the array are distinct and algorithms return true).

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.11

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

Total number of basic operations (comparison) in the worst case are,

𝟏
Other than the worst case, the total comparisons areless than 𝒏𝟐 . For example if the first two
𝟐
elements of the array are equal, only one comparison is computed. So in general C(n) =
O(n2)
Example-3: To perform matrix multiplication

Number of basic operations

(multiplications) is

Total running time:

Suppose if we take into account of addition; Algoritham also have same number of additions
A(n) = n3. Total running time:

Example-4: To count the bits in the binary representation

The basic operation is count=count + 1 repeats no. of times

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.12

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

Analysis of Recursive Algorithms

General plan for analyzing the time efficiency of recursive algorithms
1. Decide on a parameter (or parameters) indicating an input’s size.
2. Identify the algorithm’s basic operation.
3. Check whether the number of times the basic operation is executed can varyon different
inputs of the same size; if it can, the worst-case, average-case, andbest-case efficiencies
must be investigated separately.Set up a recurrence relation, with an appropriate initial
condition, for thenumber of times the basic operation is executed.
4. Solve the recurrence or, at least, ascertain the order of growth of its solution.

Example-1

Since the function F(n) is computed according to the formula

The number of multiplicationsM(n) needed to compute it must satisfy the equality

Such equations are called recurrence relations

Condition that makes the algorithm stopif n = 0 return 1. Thus recurrence relation and initial
conditionfor the algorithm’s number of multiplications M(n) can be stated as

We can use backward substitutions method to solve this

….

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.13

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

Example-2: Tower of Hanoi puzzle. In this puzzle, There are n disks of different sizes that
canslide onto any of three pegs. Initially, all the disks are on the first peg in order ofsize, the
largest on the bottom and the smallest on top. The goal is to move all thedisks to the third peg,
using the second one as an auxiliary, if necessary. We canmove only one disk at a time, and it
is forbidden to place a larger disk on top of asmaller one.The problem has an elegant recursive
solution, which is illustrated in Figure.
1. If n = 1, we move the single disk directly from the source peg to the destination peg.
2. To move n>1 disks from peg 1 to peg 3 (with peg 2 as auxiliary),
o we first move recursively n-1 disks from peg 1 to peg 2 (with peg 3 as auxiliary),
o then move the largest disk directly from peg 1 to peg 3, and,
o finally, move recursively n-1 disks from peg 2 to peg 3 (using peg 1 as auxiliary).

Figure: Recursive solution to the Tower of Hanoi puzzle

Algorithm: TowerOfHanoi(n, source, dest, aux)

If n == 1, THEN
move disk from source to dest
else
TowerOfHanoi (n - 1, source, aux, dest)
move disk from source to dest
TowerOfHanoi (n - 1, aux, dest, source)
End if

Computation of Number of Moves

The number of moves M(n) depends only on n. The recurrence equation is

We have the following recurrence relation for the number of moves M(n):

We solve this recurrence by the same method of backward substitutions:

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.14

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

The pattern of the first three sums on the left suggests that the next one will be
24M(n − 4) + 23 + 22 + 2 + 1, and generally, after i substitutions, we get

Since the initial condition is specified for n = 1, which is achieved for i = n-1, weget the
following formula for the solution to recurrence,

Example-3: To count bits of a decimal number in its binary representation

The recurrence relation can be written as

.
Also note that A(1) = 0.

The standard approach to solving such a recurrence is to solve it only for n = 2k and then take
advantage of the theorem called the smoothness rule which claims that under very broad
assumptions the order of growth observed for n = 2k gives a correct answer about the order of
growth for all values of n.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.15

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

1.4. Important Problem Types

In this section, we are going to introduce the most important problem types: Sorting, Searching,
String processing, Graph problems, Combinatorial problems.
1.4.1. Sorting
The sorting problem is to rearrange the items of a given list in non-decreasing order. As a
practical matter, we usually need to sort lists of numbers, characters from an alphabet or
character strings.
Although some algorithms are indeed better than others, there is no algorithm that would be
the best solution in all situations. Some of the algorithms are simple but relatively slow, while
others are faster but more complex; some work better on randomly ordered inputs, while others
do better on almost-sorted lists; some are suitable only for lists residing in the fast memory,
while others can be adapted for sorting large files stored on a disk; and so on.
Two properties of sorting algorithms deserve special mention. A sorting algorithm is called
stable if it preserves the relative order of any two equal elements in its input. The second
notable feature of a sorting algorithm is the amount of extra memory the algorithm requires.
An algorithm is said to be in-place if it does not require extra memory, except, possibly, for a
few memory units.
1.4.2. Searching
The searching problem deals with finding a given value, called a search key, in a given set. (or
a multiset, which permits several elements to have the same value). There are plenty of
searching algorithms to choose from. They range from the straight forward sequential search
to a spectacularly efficient but limited binary search and algorithms based on representing the
underlying set in a different form more conducive to searching. The latter algorithms are of
particular importance for real-world applications because they are indispensable for storing and
retrieving information from large databases.
1.4.3. String Processing
In recent decades, the rapid proliferation of applications dealing with non-numerical data has
intensified the interest of researchers and computing practitioners in string-handling
algorithms. A string is a sequence of characters from an alphabet. String-processing algorithms
have been important for computer science in conjunction with computer languages and
compiling issues.
1.4.4. Graph Problems
One of the oldest and most interesting areas in algorithmics is graph algorithms. Informally, a
graph can be thought of as a collection of points called vertices, some of which are connected
by line segments called edges. Graphs can be used for modeling a wide variety of applications,
including transportation, communication, social and economic networks, project scheduling,
and games. Studying different technical and social aspects of the Internet in particular is one

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.16

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

of the active areas of current research involving computer scientists, economists, and social
scientists.
1.4.5. Combinatorial Problems
Generally speaking, combinatorial problems are the most difficult problems in computing,
from both a theoretical and practical standpoint. Their difficulty stems from the following facts.
First, the number of combinatorial objects typically grows extremely fast with a problem’s size,
reaching unimaginable magnitudes even for moderate-sized instances. Second, there are no
known algorithms for solving most such problems exactly in an acceptable amount of time.

1.5. Fundamental Data Structures

Since the vast majority of algorithms of interest operate on data, particular ways of organizing
data play a critical role in the design and analysis of algorithms. A data structure can be
defined as a particular scheme of organizing related data items.
1.5.1. Linear Data Structures
The two most important elementary data structures are the array and the linked list.
A(one-dimensional) array is a sequence of n items of the same data type that are stored
contiguously in computer memory and made accessible by specifying a value of the array’s
index.

A linked list is a sequence of zero or more elements called nodes, each containing two kinds
of information: some data and one or more links called pointers to other nodes of the linked
list. In a singly linked list, each node except the last one contains a single pointer to the next
element. Another extension is the structure called the doubly linked list, in which every node,
except the first and the last, contains pointers to both its successor and its predecessor.

A list is a finite sequence of data items, i.e., a collection of data items arranged in a certain
linear order. The basic operations performed on this data structure are searching for, inserting,
and deleting an element. Two special types of lists, stacks and queues, are particularly
important.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.17

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

A stack is a list in which insertions and deletions can be done only at the end. This end is called
the top because a stack is usually visualized not horizontally but vertically—akin to a stack of
plates whose “operations” it mimics very closely.
A queue, on the other hand, is a list from which elements are deleted from one end of the
structure, called the front (this operation is called dequeue), and new elements are added to the
other end, called the rear (this operation is called enqueue). Consequently, a queue operates in
a “first-in–first-out” (FIFO) fashion—akin to a queue of customers served by a single teller in
a bank. Queues also have many important applications, including several algorithms for graph
problems.
Many important applications require selection of an item of the highest priority among a
dynamically changing set of candidates. A data structure that seeks to satisfy the needs of such
applications is called a priority queue. A priority queue is a collection of data items from a
totally ordered universe (most often, integer or real numbers). The principal operations on a
priority queue are finding its largest element, deleting its largest element, and adding a new
element.
1.5.2. Graphs
A graph is informally thought of as a collection of points in the plane called “vertices” or
nodes,” some of them connected by line segments called “edges” or “arcs.”A graph G is called
undirected if every edge in it is undirected. A graph whose every edge is directed is called
directed. Directed graphs are also called digraphs.
The graph depicted in Figure (a) has six vertices and seven undirected edges:
V = {a, b, c, d, e, f }, E = {(a, c), (a, d), (b, c), (b, f ), (c, e), (d, e), (e, f )}.
The digraph depicted in Figure 1.6b has six vertices and eight directed edges:
V = {a, b, c, d, e, f }, E = {(a, c), (b, c), (b, f ), (c, e), (d, a), (d, e), (e, c), (e, f )}.

Graph Representations- Graphs for computer algorithms are usually represented in one of
two ways: the adjacency matrix and adjacency lists.
The adjacency matrix of a graph with n vertices is an n x n boolean matrix with one row and
one column for each of the graph’s vertices, in which the element in the i th row and the jth
column is equal to 1 if there is an edge from the ith vertex to the jth vertex, and equal to 0 if
there is no such edge.

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.18

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

The adjacency lists of a graph or a digraph is a collection of linked lists, one for each vertex,
that contain all the vertices adjacent to the list’s vertex (i.e., all the vertices connected to it by
an edge).

Weighted Graphs: A weighted graph (or weighted digraph) is a graph (or digraph) with
numbers assigned to its edges. These numbers are called weights or costs.
Among the many properties of graphs, two are important for a great number of applications:
connectivity and acyclicity. Both are based on the notion of a path. A path from vertex u to
vertex v of a graph G can be defined as a sequence of adjacent (connected by an edge) vertices
that starts with u and ends with v.

A graph is said to be connected if for every pair of its vertices u and v there is a path from u to
v. Graphs with several connected components do happen in real-world applications. It is
important to know for many applications whether or not a graph under consideration has cycles.
A cycle is a path of a positive length that starts and ends at the same vertex and does not traverse
the same edge more than once.
1.5.3. Trees
A tree (more accurately, a free tree) is a connected acyclic graph. A graph that has no cycles
but is not necessarily connected is called a
forest: each of its connected components is a
tree. Trees have several important properties
other graphs do not have. In particular, the
number of edges in a tree is always one less
than the number of its vertices:|E| = |V|-1
Rooted Trees: Another very important
property of trees is the fact that for every two vertices in a tree, there always exists exactly one
simple path from one of these vertices to the other. This property makes it possible to select an
arbitrary vertex in a free tree and consider it as the root of the so-called rooted tree. A rooted

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.19

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

tree is usually depicted by placing its root on the top (level 0 of the tree), the vertices adjacent
to the root below it (level 1), the vertices two edges apart from the roots till below (level 2),
and so on.

The depth of a vertex v is the

length of the simple path from the
root to v. The height of a tree is the
length of the longest simple path
from the root to a leaf.

Ordered Trees- An ordered tree is a rooted tree in which all the children of each vertex are
ordered. It is convenient to assume that in a tree’s diagram; all the children are ordered left to
right. A binary tree can be defined as an ordered tree in which every vertex has no more than
two children and each child is designated as either a left child or a right child of its parent; a
binary tree may also be empty.
If a number assigned to each parental vertex is
larger than all the numbers in its left subtree and
smaller than all the numbers in its right subtree.
Such trees are called binary search trees.
Binary trees and binary search trees have a wide
variety of applications in computer science.

1.5.4. Sets and Dictionaries

A set can be described as an unordered collection (possibly empty) of distinct items called
elements of the set. A specific set is defined either by an explicit listing of its elements (e.g., S
= {2,3, 5, 7}) or by specifying a property that all the set’s elements and only they must satisfy
(e.g., S = {n: n is a prime number smaller than 10}).
The most important set operations are: checking membership of a given item in a given set;
finding the union of two sets, which comprises all the elements in either or both of them; and
finding the intersection of two sets, which comprises all the common elements inthe sets.
Sets can be implemented in computer applications in two ways. The first considers only sets
that are subsets of some large set U, called the universal set. If set U has n elements, then any
subset S of U can be represented by a bitstring of size n, called a bit vector, in which the ith
element is 1 if and only if the ith element of U is included in set S.
The second and more common way to represent a set for computing purposes is to use the list
structure to indicate the set’s elements. This is feasible only for finite sets. The requirement for
uniqueness is sometimes circumvented by the introduction of a multiset, or bag, an unordered

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.20

 Lecture Notes | 18CS42 – DAA | Module 1: Introduction

collection of items that are not necessarily distinct. Note that if a set is represented by a list,
depending on the application at hand, it might be worth maintaining the list in a sorted order.
Dictionary: In computing, the operations we need to perform for a set or a multiset most often
are searching for a given item, adding a new item, and deleting an item from the collection. A
data structure that implements these three operations is called the dictionary. An efficient
implementation of a dictionary has to strike a compromise between the efficiency of searching
and the efficiencies of the other two operations. They range from an unsophisticated use of
arrays (sorted or not) to much more sophisticated techniques such as hashing and balanced
search trees.
A number of applications in computing require a dynamic partition of so men-element set into
a collection of disjoint subsets. After being initialized as a collection of n one-element subsets,
the collection is subjected to a sequence of intermixed union and search operations. This
problem is called the set union problem.
*****

Prepared by Dr. Harivinod N www.harivinod.in Page | 1.21