BCSC 1204 - Data Structures & Algorithms

LECTURE 1 – INTRODUCTION TO DATA STRUCTURES & ALGORITHMS

Data Structure - Introduction
 Data Structure can be defined as the group of data elements which provides an efficient way
of storing and organizing data in the computer so that it can be used efficiently.
 Some examples of Data Structures are arrays, Linked List, Stack, Queue, etc.
 Data Structures are widely used in almost every aspect of Computer Science i.e. Operating
System, Compiler Design, Artificial intelligence, Graphics and many more.
 Data Structures are the main part of many computer science algorithms as they enable the
programmers to handle the data in an efficient way.
 It plays a vital role in enhancing the performance of a software or a program as the main
function of the software is to store and retrieve the user's data as fast as possible.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Basic Terminology

Data structures are the building blocks of any program or the software. Choosing the appropriate data
structure for a program is the most difficult task for a programmer. Following terminology is used as far
as data structures are concerned
 Data: Data can be defined as an elementary value or the collection of values, for example,
student's name and its id are the data about the student.
 Group Items: Data items which have subordinate data items are called Group item, for example,
name of a student can have first name and the last name.
 Record: Record can be defined as the collection of various data items, for example, if we talk
about the student entity, then its name, address, course and marks can be grouped together to
form the record for the student.
 File: A File is a collection of various records of one type of entity, for example, if there are 60
employees in the class, then there will be 20 records in the related file where each record
contains the data about each employee.
 Attribute and Entity: An entity represents the class of certain objects. it contains various
attributes. Each attribute represents the particular property of that entity.
 Field: Field is a single elementary unit of information representing the attribute of an entity.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Need of Data Structures

As applications are getting complex and amount of data is increasing day by day, there may arise
the following problems:
 Processor speed: To handle very large amount of data, high speed processing is required, but
as the data is growing day by day to the billions of files per entity, processor may fail to deal
with that much amount of data.
 Data Search: Consider an inventory size of 106 items in a store, If our application needs to
search for a particular item, it needs to traverse 106 items every time, results in slowing
down the search process.
 Multiple requests: If thousands of users are searching the data simultaneously on a web
server, then there are the chances that a very large server can be failed during that process
in order to solve the above problems, data structures are used.
 Data is organized to form a data structure in such a way that all items are not required to be
searched and required data can be searched instantly.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Advantages of Data Structures

 Efficiency: Efficiency of a program depends upon the choice of data structures. For example:
suppose, we have some data and we need to perform the search for a particular record. In
that case, if we organize our data in an array, we will have to search sequentially element by
element. hence, using array may not be very efficient here. There are better data structures
which can make the search process efficient like ordered array, binary search tree or hash
tables.
 Reusability: Data structures are reusable, i.e. once we have implemented a particular data
structure, we can use it at any other place. Implementation of data structures can be
compiled into libraries which can be used by different clients.
 Abstraction: Data structure is specified by the ADT which provides a level of abstraction. The
client program uses the data structure through interface only, without getting into the
implementation details.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Data Structure Classification

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Linear Data Structures:
A data structure is called linear if all of its elements are arranged in the linear order. In linear
data structures, the elements are stored in non-hierarchical way where each element has the
successors and predecessors except the first and last element.
 Arrays: An array is a collection of similar type of data items and each data item is called an
element of the array. The data type of the element may be any valid data type like char, int,
float or double.
The elements of array share the same variable name but each one carries a different index
number known as subscript. The array can be one dimensional, two dimensional or
multidimensional.
The individual elements of the array age are: age[0], age[1], age[2], age[3],......... age[98],
age[99].
 Linked List: Linked list is a linear data structure which is used to maintain a list in the
memory. It can be seen as the collection of nodes stored at non-contiguous memory
locations. Each node of the list contains a pointer to its adjacent node.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

 Stack: Stack is a linear list in which insertion and deletions are allowed only at one end,
called top.
A stack is an abstract data type (ADT), can be implemented in most of the programming
languages. It is named as stack because it behaves like a real-world stack, for example: - piles
of plates or deck of cards etc. *Last – In – First Out*
 Queue: Queue is a linear list in which elements can be inserted only at one end
called rear and deleted only at the other end called front.
It is an abstract data structure, similar to stack. Queue is opened at both end therefore it
follows First-In-First-Out (FIFO) methodology for storing the data items.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Non Linear Data Structures:
This data structure does not form a sequence i.e. each item or element is connected with two or
more other items in a non-linear arrangement. The data elements are not arranged in sequential
structure.
Types of Non Linear Data Structures are given below:
 Trees: Trees are multilevel data structures with a hierarchical relationship among its
elements known as nodes. The bottom most nodes in the hierarchy are called leaf
node while the top most node is called root node. Each node contains pointers to point
adjacent nodes.
 Tree data structure is based on the parent-child relationship among the nodes. Each node in
the tree can have more than one children except the leaf nodes whereas each node can have
at most one parent except the root node.
 Graphs: Graphs can be defined as the pictorial representation of the set of elements
(represented by vertices) connected by the links known as edges. A graph is different from
tree in the sense that a graph can have cycle while the tree can not have the one.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Operations on data structure

 Traversing: Every data structure contains the set of data elements. Traversing the data structure means
visiting each element of the data structure in order to perform some specific operation like searching or
sorting.
Example: If we need to calculate the average of the marks obtained by a student in 6 different subject,
we need to traverse the complete array of marks and calculate the total sum, then we will divide
that sum by the number of subjects i.e. 6, in order to find the average.
 Insertion: Insertion can be defined as the process of adding the elements to the data structure at any
location. If the size of data structure is n then we can only insert n-1 data elements into it.
 Deletion: The process of removing an element from the data structure is called Deletion. We can delete an
element from the data structure at any random location. If we try to delete an element from an empty data
structure then underflow occurs.
 Searching: The process of finding the location of an element within the data structure is called Searching.
There are two algorithms to perform searching, Linear Search and Binary Search. We will discuss each one of
them later in this tutorial.
 Sorting: The process of arranging the data structure in a specific order is known as Sorting. There are many
algorithms that can be used to perform sorting, for example, insertion sort, selection sort, bubble sort, etc.
 Merging: When two lists List A and List B of size M and N respectively, of similar type of elements, clubbed or
joined to produce the third list, List C of size (M+N), then this process is called merging

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Algorithm

An algorithm is a procedure having well defined steps for solving a particular problem. Algorithm
is finite set of logic or instructions, written in order for accomplish the certain predefined task. It
is not the complete program or code, it is just a solution (logic) of a problem, which can be
represented either as an informal description using a Flowchart or Pseudo code.
The major categories of algorithms are given below:
 Sort: Algorithm developed for sorting the items in certain order.
 Search: Algorithm developed for searching the items inside a data structure.
 Delete: Algorithm developed for deleting the existing element from the data structure.
 Insert: Algorithm developed for inserting an item inside a data structure.
 Update: Algorithm developed for updating the existing element inside a data structure.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Performance of Algorithm
The performance of algorithm is measured on the basis of following properties:
 Time complexity: It is a way of representing the amount of time needed by a program to run to
the completion.
 Space complexity: It is the amount of memory space required by an algorithm, during a course of
its execution. Space complexity is required in situations when limited memory is available and for
the multi user system.
Each algorithm must have:
 Specification: Description of the computational procedure.
 Pre-conditions: The condition(s) on input.
 Body of the Algorithm: A sequence of clear and unambiguous instructions.
 Post-conditions: The condition(s) on output.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Example: Design an algorithm to multiply the two numbers x and y and display the result in z.
Step 1 START
Step 2 declare three integers x, y & z
Step 3 define values of x & y
Step 4 multiply values of x & y
Step 5 store the output of step 4 in z
Step 6 print z
Step 7 STOP

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Alternatively the algorithm can be written as ?
Step 1 START MULTIPLY
Step 2 get values of x & y
Step 3 z← x * y
Step 4 display z
Step 5 STOP

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Characteristics of an Algorithm

An algorithm must follow the mentioned below characteristics:

 Input: An algorithm must have 0 or well defined inputs.
 Output: An algorithm must have 1 or well defined outputs, and should match with the
desired output.
 Feasibility: An algorithm must be terminated after the finite number of steps.
 Independent: An algorithm must have step-by-step directions which is independent of any
programming code.
 Unambiguous: An algorithm must be unambiguous and clear. Each of their steps and
input/outputs must be clear and lead to only one meaning.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Asymptotic Analysis

In mathematical analysis, asymptotic analysis of algorithm is a method of defining the mathematical

foundation of its run-time performance. Using the asymptotic analysis, we can easily conclude about
the average case, best case and worst case scenario of an algorithm.
 It is used to mathematically calculate the running time of any operation inside an algorithm.
 Example: Running time of one operation is x(n) and for another operation it is calculated as f(n2).
It refers to running time will increase linearly with increase in 'n' for first operation and running
time will increase exponentially for second operation. Similarly the running time of both
operations will be same if n is significantly small.
Usually the time required by an algorithm comes under three types:
 Worst case: It defines the input for which the algorithm takes the huge time.
 Average case: It takes average time for the program execution.
 Best case: It defines the input for which the algorithm takes the lowest time.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Asymptotic Notations

The commonly used asymptotic notations used for calculating the running time complexity of an
algorithm is given below:
 Big oh Notation (Ο)
 Omega Notation (Ω)
 Theta Notation (θ)

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Big oh Notation (O)

 It is the formal way to express the upper boundary of an algorithm running time.
 It measures the worst case of time complexity or the longest amount of time, algorithm
takes to complete their operation. It is represented as shown below:

 For example: If f(n) and g(n) are the two functions

defined for positive integers, then f(n) is
O(g(n)) as f(n) is big oh of g(n) or f(n) is on the
order of g(n)) if there exists constants c and no
such that:
 F(n)≤cg(n) for all n≥no
 This implies that f(n) does not grow faster than
g(n), or g(n) is an upper bound on the function
f(n).

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Omega Notation (Ω)
 It is the formal way to represent the lower bound of an algorithm's running time. It measures
the best amount of time an algorithm can possibly take to complete or the best case time
complexity.
 If we required that an algorithm takes at least certain amount of time without using an
upper bound, we use big- Ω notation i.e. the Greek letter "omega". It is used to bound the
growth of running time for large input size.
 If running time is Ω (f(n)), then for the larger value
of n, the running time is at least k?f(n) for constant (k).
 It is represented as shown below:

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Theta Notation (?)

 It is the formal way to express both the upper bound and lower bound of an algorithm
running time.
 Consider the running time of an algorithm is θ (n), if at once (n) gets large enough the
running time is at most k2-n and at least k1 ?n for some constants k1 and k2. It is
represented as shown below:

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Common Asymptotic Notations

constant - f(1)
linear - f(n)
logarithmic - f(log n)
n log n - f(n log n)
2
exponential - f(n)
3
cubic - f(n )
n
polynomial - f(1)
2
quadratic - f(n )

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Pointer
 Pointer is used to points the address of the value stored anywhere in the computer memory.
To obtain the value stored at the location is known as dereferencing the pointer. Pointer
improves the performance for repetitive process such as:
 Traversing String
 Lookup Tables
 Control Tables
 Tree Structures

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

 Pointer Details

 Pointer arithmetic: There are four arithmetic operators that

can be used in pointers: ++, --, +, -
 Array of pointers: You can define arrays to hold a number of
pointers.
 Pointer to pointer: C allows you to have pointer on a pointer
and so on.
 Passing pointers to functions in C: Passing an argument by
reference or by address enable the passed argument to be
changed in the calling function by the called function.
 Return pointer from functions in C: C allows a function to
return a pointer to the local variable, static variable and
dynamically allocated memory as well.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Program Example - Pointer
Output
#include <stdio.h>
value of a = 5
int main( )
value of a = 5
{
address of a = 3010494292
int a = 5;
address of a = -1284473004
int *b; address of b = 3010494296
b = &a; value of b = address of a = 3010494292

printf ("value of a = %d\n", a);

printf ("value of a = %d\n", *(&a));
printf ("value of a = %d\n", *b);
printf ("address of a = %u\n", &a);
printf ("address of a = %d\n", b);
printf ("address of b = %u\n", &b);
printf ("value of b = address of a = %u", b);
return 0;
}

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Program Example - Pointer to Pointer

#include <stdio.h> printf ("value of a = %d\n", **c);

int main( ) printf ("value of b = address of a = %u\n", b);
{ printf ("value of c = address of b = %u\n", c);
int a = 5; printf ("address of a = %u\n", &a);
int *b; printf ("address of a = %u\n", b);
int **c; printf ("address of a = %u\n", *c);
b = &a; printf ("address of b = %u\n", &b);
c = &b; printf ("address of b = %u\n", c);
printf ("value of a = %d\n", a); printf ("address of c = %u\n", &c);
printf ("value of a = %d\n", *(&a)); return 0;
printf ("value of a = %d\n", *b); }

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Output
value of a = 5
value of a = 5
value of a = 5
value of a = 5
value of b = address of a = 2831685116
value of c = address of b = 2831685120
address of a = 2831685116
address of a = 2831685116
address of a = 2831685116
address of b = 2831685120
address of b = 2831685120
address of c = 2831685128

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Structure

A structure is a composite data type that defines a grouped list of variables that are to be placed
under one name in a block of memory. It allows different variables to be accessed by using a single
pointer to the structure.
Syntax
struct structure_name
{
data_type member1;
data_type member2;
.
.
data_type memeber;
};
BCSC 1204 - DATA STRUCTURE & ALGORITHMS
Advantages

 It can hold variables of different data types.

 We can create objects containing different types of attributes.
 It allows us to re-use the data layout across programs.
 It is used to implement other data structures like linked lists, stacks, queues, trees, graphs
etc.

BCSC 1204 - DATA STRUCTURE & ALGORITHMS

Program
#include<stdio.h> printf ("\nEnter ids, salary & mobile no. of 3 employee\
n"
#include<conio.h>
scanf ("%d %f %d", &e1.id, &e1.salary, &e1.mobile);
void main( )
scanf ("%d%f %d", &e2.id, &e2.salary, &e2.mobile);
{
scanf ("%d %f %d", &e3.id, &e3.salary, &e3.mobile);
struct employee
printf ("\n Entered Result ");
{
printf ("\n%d %f %d", e1.id, e1.salary, e1.mobile);
int id ;
printf ("\n%d%f %d", e2.id, e2.salary, e2.mobile);
float salary ;
printf ("\n%d %f %d", e3.id, e3.salary, e3.mobile);
int mobile ;
getch();
};
}
struct employee e1,e2,e3 ;
clrscr();

BCSC 1204 - DATA STRUCTURE & ALGORITHMS