18CSC201J- DATA STRUCTURE AND

ALGORITHM

UNIT-1
1.1 INTRODUCTION-BASIC TERMINOLOGY

Data Structure is a way of collecting and organising data in such a way that we can perform
operations on these data in an effective way.

Basic Terminology of Data Organization:

Data : The term ‘DATA’ simply refers to a value or a set of values. These values may present anything
about something, like it may be roll no of a student, marks, name of an employee, address of person
etc.

Data item : A data item refers to a single unit of value. For eg. roll no of a student, marks, name of an
employee, address of person etc. are data items. Data items that can be divided into sub items are
called group items (Eg. Address, date, name), where as those who can not be divided in to sub items
are called elementary items (Eg. Roll no, marks, city, pin code etc.).

Entity with similar attributes ( e.g all employees of an organization) form an entity set
Basic Terminology of Data Organization(Cont..):
Information: processed data, Data with given attribute
Field : It is a single elementary unit of information representing an attribute of an entity
Record is the collection of field values of a given entity
File is the collection of records of the entities in a given entity set
1.2 BASIC TYPES OF DATA STRUCTURES:
Anything that can store data can be called as a data structure, hence Integer, Float, Boolean, Char etc, all are
data structures. They are known as Primitive Data Structures.
Then we also have some complex Data Structures, which are used to store large and connected data. Some
example of Abstract Data Structure are :
• Array
• Linked List
• Stack
• Queue
• Tree
• Graph
Classification of Data Structure:

The data structures are classified into primitive(simple) and non-

primitive(compound).

Primitive data structures are the fundamental data types which are
supported by a programming language. Some basic data types are
integer, real, character, and boolean. The terms ‘data type’, ‘basic
data type’, and ‘primitive data type’ are often used interchangeably.

Non-primitive data structures are those data structures which are

created using primitive data structures. Examples of such data
structures include linked lists, stacks, trees, and graphs.

Non-primitive data structures can further be classified into two

categories: linear and non-linear data structures.

If the elements of a data structure are stored in a linear or sequential

order, then it is a linear data structure. Examples include arrays,
linked lists, stacks, and queues.
1.3 BASIC DATA STRUCTURE OPERATIONS
The data in the data structures are processed by certain operations. The particular data structure chosen
largely depends on the frequency of the operation that needs to be performed on the data structure.

• Traversing • Searching • Insertion • Deletion • Sorting • Merging

(1) Traversing: Accessing each record exactly once so that certain items in the record may be processed.
(2) Searching: Finding the location of a particular record with a given key value, or finding the location of
all records which satisfy one or more conditions.
(3) Inserting: Adding a new record to the structure.
(4) Deleting: Removing the record from the structure.
(5) Sorting: Managing the data or record in some logical order (Ascending or descending order).
(6) Merging: Combining the record in two different sorted files into a single sorted file.

1.4 Abstract Data Types (ADT)

An abstract data type (ADT) refers to a set of data values and associated operations that are specified
accurately, independent of any particular implementation. With an ADT, we know what a specific data
type can do, but how it actually does it is hidden. Simply hiding the implementation
1.5 TIME AND SPACE COMPLEXITY
• The time complexity of an algorithm is basically the running time of a program as a function of the
input size.
• Similarly, the space complexity of an algorithm is the amount of computer memory that is required
during the program execution as a function of the input size

Worst-case, Average-case, Best-case, and Amortized Time Complexity

Worst-case running time: This denotes the behaviour of an algorithm with respect to the worst-
possible case of the input instance. The worst-case running time of an algorithm is an upper bound on
the running time for any input.

Average-case running time: The average-case running time of an algorithm is an estimate of the
running time for an ‘average’ input.

Best-case running time: The term ‘best-case performance’ is used to analyse an algorithm under
optimal conditions. For example, the best case for a simple linear search on an array occurs when the
desired element is the first in the list.

Amortized running time: Amortized running time refers to the time required to perform a sequence of
(related) operations averaged over all the operations performed.
1.6 TIME–SPACE TRADE-OFF

The best algorithm to solve a particular problem at hand is no doubt the one that requires less
memory space and takes less time to complete its execution. But practically, designing such an
ideal algorithm is not a trivial task.

There can be more than one algorithm to solve a particular problem. One may require less
memory space, while the other may require less CPU time to execute.

Thus, it is not uncommon to sacrifice one thing for the other. Hence, there exists a time–space
trade-off among algorithms
1.7 Asymptotic Notations
The main idea of asymptotic analysis is to have a
measure of efficiency of algorithms that doesn’t
depend on machine specific constants, and doesn’t
require algorithms to be implemented and time
taken by programs to be compared. Asymptotic
notations are mathematical tools to represent time
complexity of algorithms for asymptotic analysis.
The following 3 asymptotic notations are mostly
used to represent time complexity of algorithms.

1) Θ Notation:
The theta notation bounds a function from above
and below, so it defines exact asymptotic behavior.
A simple way to get Theta notation of an expression
is to drop low order terms and ignore leading
constants.
Asymptotic Notations (Cont..)

2. Big O Notation:
The Big O notation defines an upper bound of an
algorithm, it bounds a function only from above. For
example, consider the case of Insertion Sort. It takes
linear time in best case and quadratic time in worst
case.
Asymptotic Notations (Cont..)

3) Ω Notation:

Just as Big O notation provides an asymptotic upper bound on a function, Ω notation provides an
asymptotic lower bound. Ω Notation can be useful when we have lower bound on time
complexity of an algorithm.
1.8 MATHEMATICAL FUNCTIONS:

1. Floor and Ceiling Functions:

If x is a real number, then it means that x lies between two integers which are called the
floor and ceiling of x. i.e.

|_x_| is called the floor of x. It is the greatest integer that is not greater than x.
| x | is called the ceiling of x. It is the smallest integer that is not less than x.

2. Remainder Function (Modular Arithmetic):

If k is any integer and M is a positive integer, then:

k (mod M)

gives the integer remainder when k is divided by M.

E.g.

25(mod 7) = 4
25(mod 5) = 0
MATHEMATICAL FUNCTIONS (Cont..):

3. Integer and Absolute Value Functions:

If x is a real number, then integer function INT(x) will convert x into integer and the fractional part is removed.
E.g.
INT (3.14) = 3
INT (-8.5) = -8

4. Summation Symbol (Sums):

The symbol which is used to denote summation is a Greek letter Sigma ?.

Let a1, a2, a3, ….. , an be a sequence of numbers. Then the sum a1 + a2 + a3 + ….. + an will be written as:

n
? aj
j=1

where j is called the dummy index or dummy variable.

E.g.
n
? j = 1 + 2 + 3 +…..+ n
j=1
MATHEMATICAL FUNCTIONS (Cont..):

5. Factorial Function:

n! denotes the product of the positive integers from 1 to n. n! is read as ‘n factorial’, i.e.
n! = 1 * 2 * 3 * ….. * (n-2) * (n-1) * n
E.g.
4! = 1 * 2 * 3 * 4 = 24

6. Permutations:

Let we have a set of n elements. A permutation of this set means the arrangement of the elements of the set in some order.
E.g.
Suppose the set contains a, b and c. The various permutations of these elements can be: abc, acb, bac, bca, cab, cba.
If there are n elements in the set then there will be n! permutations of those elements. It means if the set has 3 elements
then there will be 3! = 1 * 2 * 3 = 6 permutations of the elements.

7. Exponents and Logarithms:

Exponent means how many times a number is multiplied by itself. If m is a positive integer, then:
am = a * a * a * ….. * a (m times)
and
a-m = 1 / am
E.g.
24 = 2 * 2 * 2 * 2 = 16
1.9 SORTING - BUBBLE SORT:

Bubble sort is a very simple method that sorts the array elements by repeatedly moving the largest
element to the highest index position of the array segment (in case of arranging elements in
ascending order). In bubble sorting, consecutive adjacent pairs of elements in the array are
compared with each other. If the element at the lower index is greater than the element at the
higher index, the two elements are interchanged so that the element is placed before the bigger one.
This process will continue till the list of unsorted elements exhausts. The pseudocode for Bubble sort
is given below:

The complexity of bubble sort algorithm is O(n^2 ).

1.10 INSERTION SORT

Worst Case Time Complexity : O(n^2)

1.11 SEARCHING

Searching means to find whether a particular value is present in an array or not. If the value is present
in the array, then searching is said to be successful and the searching process gives the location of that
value in the array. However, if the value is not present in the array, the searching process displays an
appropriate message and in this case searching is said to be unsuccessful. There are two popular
methods for searching the array elements: linear search and binary search.

LINEAR SEARCH:

Linear Search Linear search, also called as sequential search, is a very simple method used for
searching an array for a particular value. It works by comparing the value to be searched with every
element of the array one by one in a sequence until a match is found. Linear search is mostly used to
search an unordered list of elements (array in which data elements are not sorted).

For example, if an array A[] is declared and initialized as, int A[] = {10, 8, 2, 7, 3, 4, 9, 1, 6, 5}; and the
value to be searched is VAL = 7, then searching means to find whether the value ‘7’ is present in the
array or not. If yes, then it returns the position of its occurrence. Here, POS = 3 (index starting from 0).
ALGORITHM FOR LINEAR SEARCH:

Complexity of Linear Search Algorithm

• Linear search executes in O(n) time where n is the

number of elements in the array.
• Obviously, the best case of linear search is when VAL
is equal to the first element of the array. In this case,
only one comparison will be made.
• Likewise, the worst case will happen when either
VAL is not present in the array or it is equal to the
last element of the array. In both the cases, n
comparisons will have to be made.
1.12 BINARY SEARCH

Binary search is a searching algorithm that works efficiently with a sorted list.

Let us consider how this mechanism is applied to search for a value in a sorted array. Consider an array
A[] that is declared and initialized as int A[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};and the value to be
searched is VAL = 9.

The algorithm will proceed in the following manner.

BEG = 0, END = 10, MID = (0 + 10)/2 = 5

Now, VAL = 9 and A[MID] = A[5] = 5A[5] is less than VAL, therefore, we now search for the value in the
second half of the array.

So, we change the values of BEG and MID.

Now, BEG = MID + 1 = 6, END = 10, MID = (6 + 10)/2 =16/2 = 8 ,VAL = 9 and A[MID] = A[8] = 8A[8] is less
than VAL, therefore, we now search for the value in the second half of the segment.

So, again we change the values of BEG and MID. Now, BEG = MID + 1 = 9, END = 10, MID = (9 + 10)/2 =
9Now, VAL = 9 and A[MID] = 9.
BINARY SEARCH(Cont..)
ALGORITHM FOR BINARY SEARCH

However, if VAL is not equal to A[MID], then

the values of BEG, END, and MID will be
changed depending on whether VAL is smaller
or greater than A[MID].

(a)If VAL < A[MID], then VAL will be present in

the left segment of the array. So, the value of
END will be changed as END = MID – 1.

(b)If VAL > A[MID], then VAL will be present in

the right segment of the array. So, the value of
BEG will be changed as BEG = MID + 1.

Finally, if VAL is not present in the array, then

eventually, END will be less than BEG. When
this happens, the algorithm will terminate and
the search will be unsuccessful.

Complexity of Binary Search Algorithm -

1.13 1D ARRAY WITH POINTERS:

The concept of array is very much bound to the concept of pointer. For example, if we have an array
declared as, int arr[] = {1, 2, 3, 4, 5}; then in memory it would be stored as shown below

Here, ptr is made to point to the first element of the array. Execute the code given below and observe the
output which will make the concept clear to you.
main()
{
int arr[]={1,2,3,4,5};
printf("\n Address of array = %p %p %p", arr, &arr[0], &arr);
}

Similarly, writing ptr=&arr[2] makes ptr to point to the third element of the array that has index 2.
1D ARRAY WITH POINTERS(cont..):
1.14 2D ARRAY WITH POINTERS:

A two dimensional array using pointer is an array of one dimensional array.

Let us suppose a two-dimensional array

int matrix[3][3];

For the above array,

matrix => Points to base address of two-dimensional array.
Since array decays to pointer.

*(matrix) => Points to first row of two-dimensional array.

*(matrix + 0) => Points to first row of two-dimensional array.
*(matrix + 1) => Points to second row of two-dimensional array.

**matrix => Points to matrix[0][0]

*(*(matrix + 0)) => Points to matrix[0][0]
*(*(matrix + 0) + 0) => Points to matrix[0][0]
*(*matrix + 1) => Points to matrix[0][1]
*(*(matrix + 0) + 1) => Points to matrix[0][1]
*(*(matrix + 2) + 2) => Points to matrix[2][2]
2D ARRAY WITH POINTERS(Cont..):
Program to access a two dimensional array using pointer
{
#include <stdio.h> // (*(matrix + i) + j is equivalent to &matrix[i][j]
#define ROWS 3 scanf("%d", (*(matrix + i) + j));
#define COLS 3 }
void inputMatrix(int matrix[][COLS], int rows, int cols); }
void printMatrix(int matrix[][COLS], int rows, int cols); }
int main() void printMatrix(int (*matrix)[COLS], int rows, int cols)
{ {
int matrix[ROWS][COLS]; int i, j;
int i, j; for (i = 0; i < rows; i++)
printf("Enter elements in %dx%d matrix.\n", ROWS, {
COLS); for (j = 0; j < cols; j++)
inputMatrix(matrix, ROWS, COLS); {
printf("Elements of %dx%d matrix.\n", ROWS, COLS); // *(*(matrix + i) + j) is equivalent to matrix[i][j]
printMatrix(matrix, ROWS, COLS); printf("%d ", *(*(matrix + i) + j));
return 0; }
}
void inputMatrix(int matrix[][COLS], int rows, int cols) printf("\n");
{ }
int i, j; }
for(i = 0; i < rows; i++)
{
for(j = 0; j < cols; j++)
1.15 STRUCTURE:
It is a collection of variables under a single name. The variables within a structure are of different data types and
each has a name that is used to select it from the structure.

Initialization of Structure:
1.16 ACCESSING THE MEMBERS OF A STRUCTURE
1.17 ARRAY OF STRUCTURES:
REFERENCE:

DATA STRUCTURES USING C, REEMA THAREJA

2D ARRAY WITH POINTER - https://codeforwin.org/2017/12/access-two-dimensional-array-using-pointers-c-

programming.html

MATHEMATICAL FUNCTIONS -http://www.xpode.com/ShowArticle.aspx?ArticleId=132