Data Structures

(CSN12101)
Prerequisite: C programming and Basic of Mathematics
L-T-P: 2-0-2, Credits: 3
Type: Engineering Essential/ Core Essential

Dr Deepak Gupta
Assistant Professor, SMIEEE
CSED, MNNIT Allahabad, Prayagraj
Email: [email protected]
 Course Description

This course introduces the student’s fundamentals of data structures and takes
them forward to software design along with the course on Algorithms. It details
how the choice of data structures impacts the performance of programs for given
software application. This is a precursor to DBMS and Operating Systems. A lab
course is associated with it to strengthen the concepts.
 Syllabus
UNIT 1: Introduction: Basic Terminology, Elementary Data Organization, Algorithm,
Efficiency of an Algorithm, Time and Space Complexity, Asymptotic notations: Theta,
Big-O, and Omega, Time-Space trade-off. Abstract Data Types (ADT)
UNIT II: Arrays: Definition, Single and Multidimensional Arrays, Representation of
Arrays: Row Major Order, and Column Major Order, Application of arrays, Sparse
Matrices and their representations.
Linked Lists: Array Implementation and Dynamic Implementation of Singly Linked
Lists, Doubly Linked List, Circularly Linked List, Operations on a Linked List.
Insertion, Deletion, Traversal, Polynomial Representation and Addition, Generalized
Linked List
Stacks: Abstract Data Type, Primitive Stack operations: Push & Pop, Array and Linked
Implementation of Stack in C, Application of stack: Prefix and Postfix Expressions,
Evaluation of postfix expression, Recursion, Tower of Hanoi Problem, Simulating
Recursion, Principles of recursion, Tail recursion, Removal of recursion
Queues: Abstract Data Type, Operations on Queue: Create, Add, Delete, Full and
Empty, Circular queues, Array and linked implementation of queues in C, Deque and
Priority Queue.
 Syllabus

UNIT III: Basic terminology, k-ary trees, Binary Trees, Binary Tree Representation: Array
Representation and Dynamic Representation, Complete Binary Tree, Algebraic Expressions,
Extended Binary Trees, Array and Linked Representation of Binary trees, Tree Traversal
algorithms: In order, Preorder and Post order, Binary Search Trees, Threaded Binary trees,
Traversing Threaded Binary trees, Forest, Huffman algorithm, Heap, B/B+ Tree, AVL tree
UNIT IV: Sequential search, Binary Search, Comparison and Analysis Internal Sorting:
Bubble Sort, Selection Sort, Insertion Sort, Two Way Merge Sort, Heap Sort, Quick Sort,
Hashing
Unit V: Terminology, Sequential and linked Representations of Graphs: Adjacency Matrices,
Adjacency List, Adjacency Multi list, Graph Traversal: Depth First Search and Breadth First
Search, Connected Component, Spanning Trees, Minimum Cost Spanning Trees: Prims and
Kruskal algorithm. Shortest Path algorithm: Dijikstra Algorithm
 Books

Text Books:

1. Aaron M. Tenenbaum, YedidyahLangsam and Moshe J. Augenstein “Data

Structures Using C and C++”, PHI

Reference Books:
1. Horowitz and Sahani, “Fundamentals of Data Structures”, Galgotia
Publication
2. Donald Knuth, “The Art of Computer Programming”, vol. 1 and vol. 3.
3. Jean Paul Trembley and Paul G. Sorenson, “An Introduction to Data
Structures with applications”, McGraw Hill
4. R. Kruse et al, “Data Structures and Program Design in C”, Pearson
Education
5. Lipschutz, “Data Structures” Schaum’s Outline Series, TM
 Time Table
9:00-10:00 10:00-11:00 11:00-12:00 12:00-1:00 1:00-2:00 2:00-3:00 3:00-4:00 4:00-5:00

CSN12101(L)D
MON
GS5

CSN12101(P)D2 CSN12101(P)B1 CSN12101(L)A

TUE
CCTF CCTF GS4

CSN12101(L)D CSN12101(P)D1 CSN12101(L)C

WED
GS4 CCSF GS5

CSN12101(L)A CSN12101(L)B CSN12101(P)B2

THU
GS4 GS7 CCTF

CSN12101(L)C CSN12101(L)B
FRI
GS7 GS6
 Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India
Introduction
Data: Data is the plural of “datum” (which is rarely used) and may be thought
of as representing numbers, words, facts, figures, images, etc.

Raw Data: A collection of such data which needs further processing by

computers or human being is referred to as Raw Data.
For example, a collection of data related to the marks of students. It may
processed to get the average marks of the class.

Information: If data is arranged in some systematic way then it gets a

structure and becomes meaningful. This meaningful or processed data is
called information.
Knowledge: Knowledge is useful information that supports decision-making.
Data
Abstraction
Information
Abstraction
Knowledge
Fig: Process of Abstraction
Abstraction: The process of providing only the essentials and hiding the
details is known as Abstraction.

Data Type: A data type is a collection of objects and a set of operations that
act on those objects.
For example in C, int data type can take values in a range and operations that
can be performed are addition, subtraction, multiplication, division, bitwise
operations etc.
Data type or Primitive Data types are the predefined data types that are
supported in the programming language. The size depends upon the type of
data type. Primitive Data types can hold only a single value in one specific
location.

Examples of data types are integer, character, float, Boolean, etc.

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

Data Structures: Data Structure is a particular way of storing and organizing
data in the memory of the computer so that these data can easily be retrieved
and efficiently utilized in the future when required. It is the physical
implementation of Abstract data types (ADTs).

Figure 2: Classifications of Data Structures

Primitive Data Structure/ Types
Primitive data structures are built into a programming language and are
generally considered the most basic data types. They are called primitive
because they are not composed of any other data types.
Examples of primitive data structures include integers, float, characters,
and boolean values.

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

Non-Primitive Data Structures
These are more complex data types that are composed of primitive data
types or other non-primitive data types. They are also referred to as
composite data types or reference data types.
Examples of non-primitive data structures include arrays, stacks,
queues, and trees.

Based on the structure and arrangement of data, we can divide non-

primitive data structures into two sub-categories:
1. Linear Data Structures

2. Non-Linear Data Structures

Linear Data Structures
A data structure that preserves a linear connection among its data elements is
known as a Linear Data Structure. The arrangement of the data is done
linearly, where each element consists of the successors and predecessors
except the first and the last data elements.
However, it is not necessarily true in the case of memory, as the
arrangement may not be sequential.

Based on memory allocation, the Linear Data Structures are further

classified into two types:

Linear Data Structures

Static Data Structures Dynamic Data Structures

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

Static Data Structures:
The data structures having a fixed size are known as Static Data Structures.
The memory for these data structures is allocated at the compiler time, and
their size cannot be changed by the user after being compiled; however, the
data stored in them can be altered.
Example: The Array has a fixed size, and its data can be modified later.

An Array is a data structure used to collect multiple data elements of the

same data type into one variable.
• Arrays are declared using the following syntax:
type name[size];

int marks[10];

marks[0] marks[1] marks[2] marks[3] marks[4] marks[5] marks[6] marks[7] marks[8] marks[9]

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

Dynamic Data Structures:
The data structures having a dynamic size are known as Dynamic Data
Structures. The memory of these data structures is allocated at the run time,
and their size varies during the run time of the code. Moreover, the user
can change the size as well as the data elements stored in these data
structures at the run time of the code.

Example: Linked Lists, Stacks, and Queues are common examples of

dynamic data structures.

Linked Lists
A Linked List is another example of a linear data structure used to store a
collection of data elements dynamically. Data elements in a linked list are
represented by the nodes, connected using links or pointers.

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

Stack
A Stack is a Linear Data Structure that follows the LIFO (Last In, First Out)
principle that allows operations like insertion and deletion from one end of
the Stack, i.e., Top.
Real-life examples of Stacks are piles of books,
a deck of cards, piles of money, and many
more.

Queue
It follows the First-In-First-Out (FIFO) principle. Elements are inserted at the
back of the queue and removed from the front.
Non-Linear Data Structures
Non-Linear Data Structures are data structures where the data elements are
not arranged in sequential order. Here, the insertion and removal of data are
not feasible in a linear manner. There exists a hierarchical relationship
between the individual data items.

Example: Tree and Graph are common examples of Non-linear data

structures.
Tree:
A Tree is a non-linear data structure and a hierarchy containing a collection
of nodes such that each node of the tree stores a value and a list of references
to other nodes (the "children").
Graph:
A Graph is another example of a Non-Linear Data Structure comprising a
finite number of nodes or vertices and the edges connecting them.
The Graph data structure, G is considered a mathematical structure
comprised of a set of vertices, V, and a set of edges, E as shown below:

G = (V, E)
Algorithm: An algorithm is a finite set of instructions that, if followed,
accomplishes a particular task.
In addition, all algorithms must satisfy the following criteria:
1. Input: There are zero or more quantities that are externally supplied.

2. Output: At least one quantity is produced.

3. Definiteness: Each instruction is clear and unambiguous.

4. Finiteness: The algorithm terminates after a finite number of steps.

5. Effectiveness: Every instruction must be basic enough to be carried out.

Program: A program is a language specific implementation of the algorithm.

It does not satisfy the fourth condition.
Analysis of Algorithms: Analysis of algorithms is required to dictate the
correctness and measure the quantitative efficiency of an algorithm. There may
be many algorithms for solving any problem and we would like to use the most
efficient one.
Analysis of algorithms is required to compare these algorithms and recognize
the best one based on the following criteria:
 Time Complexity
 Space Complexity

 Space Complexity: The space complexity of an algorithm is the amount of

computer memory required during the program execution, as a function of
the input size.

 Time Complexity: The time complexity of an algorithm is basically the

running time of the program as a function of the input size.
The running time of the algorithm is the sum of the running times of each
statement.
 The space needed by a program depends on:

 The fixed part includes space needed for storing instructions, constants,
variables, and structured variables. It does not depend on the size of
program’s inputs and outputs.
float abc(float a, float b, float c)
{ Sabc(I) = 0.
return a+b+b*c+(a+b-c)/(a+b)+4
}
 Variable part consists of the space needed by structured variables whose
size depends on the particular instance (I), of the problem being solved.
It also includes space needed for the recursion stack, and for structured
variables that are allocated space dynamically during the run-time of the
program.
Type Name Number of bytes
Ex: Recursive function for summing a list
Parameter: array pointer list[] 4
of numbers
float rsum(float list[], int n) Parameter: integer n 4
{
return address 4
if (n) return rsum(list, n-1)+list(n-1);
return 0; Total per recursive call 12
}
Srsum(Max_size) = 12*Max_size.
Ex: Iterative function for summing a list of numbers
float sum(float list[], int n)
{
float tempsum = 0;
int i; Sabc(I) = 0.
for(i=0; i<n; i++)
tempsum += list[i];
return tempsum
} Time Complexity
Ex: Recursive function for summing a list of numbers
float rsum(float list[], int n)
{
if (n)
return rsum(list, n-1)+list(n-1);
return 0;
}

Time Complexity
Ex: Matrix Addition
void add (int a[ ][MAX_SIZE], int b[ ][MAX_SIZE], int c[ ][MAX_SIZE], int rows, int cols)
{
int i, j;
for (i=0; i<rows; i++)
for (j=0; j<cols; j++)
c[i][j] = a[i][j] + b[i][j];
}
 Categories of Algorithms

• Constant time algorithms have running time complexity given as O(1)

• Linear time algorithms have running time complexity given as O(n)
• Logarithmic time algorithms have running time complexity given as
O(log n)
• Polynomial time algorithms have running time complexity given as
O(nk) where k>1
• Exponential time algorithms have running time complexity given as
O(2n)

n O(1) O(log n) O(n) O(n log n) O(n2) O(n3) O(2n)

1 1 1 1 1 1 1 2

2 1 1 2 2 4 8 4

4 1 2 4 8 16 64 8

8 1 3 8 24 64 512 256

16 1 4 16 64 256 4,096 65536

 Array
Array: An array is a collection of similar data elements of the same type.

Elements of arrays are stored in consecutive memory locations and are

referenced by an index (also known as the subscript).

1-D Arrays are declared using the following syntax:

data_type name[size];
data_type - what kind of values it can store. For example, int, char, float
name - to identify the array
size - the maximum number of values that the array can hold

int marks[10];

marks[0] marks[1] marks[2] marks[3] marks[4] marks[5] marks[6] marks[7] marks[8] marks[9]

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

The symbolic constants can be used to specify the size of an array. However,
we can’t use the variables for specifying the size of array in the declaration for
older C.
#define SIZE 10
main()
{
int size = 15;
int marks[SIZE]; /*valid*/
Int marks[size]={2,3,5}; /*not valid in older C*/
…
}

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

Accessing Elements of 1-D Arrays

To access all the elements of an array, we must use a loop.

That is, we can access all the elements of an array by varying the value of the
subscript in the array.

int i, marks[10];
for(i=0;i<10;i++)
printf(“%d ”,marks[i]);

Processing 1-D Arrays

Reading values in marks: for(i=0;i<10;i++)
scanf(“%d ”,&marks[i]);
Display values of marks: for(i=0;i<10;i++)
printf(“%d ”,marks[i]);

Adding all the elements of marks: sum=0;

for(i=0;i<10;i++)
sum+=marks[i];
Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India
Calculating the Address of Array Elements:

Address of data element, marks[k] = BA(marks) + w( k – lower_bound)

where, marks is the array

k is the index of the element whose address we have to calculate
BA is the base address of the array marks
w is the word size of one element in memory.
lower_bound = 0

marks[0] marks[1] marks[2] marks[3] marks[4] marks[5] marks[6] marks[7]

1000 1002 1004 1006 1008 1010 1012 1014

marks[4] = 1000 + 2(4 – 0)

= 1000 + 2(4) = 1008

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

Initialization of 1-D Array

The syntax initialization of an array is:

data_type array_name[size] = {value1, value2, …., valueN};

For example:
int marks[5]={99,78,55,23,91};
int marks[ ]={99,78,55,23,91};

int marks[5]={99,78};
Here, the size of the array is 5 while there are only 2 initializers. The value of
the elements are:
marks[0]=99 marks[1]=78 marks[2]=0 marks[3]=0 marks[4]=0

int marks[5]={99,78,55,23,91,76}; /*error*/

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

We can’t copy all the elements of an array to another array by assigning it to
the other array. For example
int marks[5]={99,78,55,23,91};
int b[5];
b=marks; /*error*/

We will have to copy all elements of the array one by one by using a for
loop:
for(i=0;i<5;i++)
b[i]=marks[i];

Prepared by: Dr Deepak Gupta, CSED, MNNIT Allahabad, India

WAP to Read and Display N Numbers using an Array
#include<stdio.h>
#include<conio.h>
int main()
{
int i=0, n, arr[20];
clrscr();
printf(“\n Enter the number of elements : ”);
scanf(“%d”, &n);
printf(“\n Enter the elements : ”);
for(i=0;i<n;i++)
{
printf(“\n arr[%d] = ”, i);
scanf(“%d”, &num[i]);
}
printf(“\n The array elements are ”);
for(i=0; i<n; i++)
printf(“arr[%d] = %d\t”, i, arr[i]);
return 0;
}
Inserting an Element in an Array

Algorithm to insert a new element to the end of an array

Step 1: Set upper_bound = upper_bound + 1
Step 2: Set A[upper_bound] = VAL
Step 3: EXIT

Algorithm INSERT( A, N, POS, VAL) to insert an element VAL at

position POS
Step 1: [INITIALIZATION] SET I = N
Step 2: Repeat Steps 3 and 4 while I >= POS
Step 3: SET A[I + 1] = A[I]
Step 4: SET I = I – 1
[End of Loop]
Step 5: SET N = N + 1
Step 6: SET A[POS] = VAL
Step 7: EXIT
Deleting an Element in an Array

Algorithm to delete a new element to the end of an array

Step 1: Set upper_bound = upper_bound - 1
Step 2: EXIT

Algorithm DELETE( A, N, POS) to delete an element at POS

Step 1: [INITIALIZATION] SET I = POS

Step 2: Repeat Steps 3 and 4 while I <= N-1
Step 3: SET A[I] = A[I + 1]
Step 4: SET I = I + 1
[End of Loop]
Step 5: SET N = N - 1
Step 6: EXIT
Passing Arrays to Functions

1D Arrays For Inter Function

Communication

Passing individual elements Passing entire array

Passing data values Passing addresses

Passing data values

main() void func(int num)
{ {
int arr[5] ={1, 2, 3, 4, 5}; printf("%d", num);
func(arr[3]); }
}
Passing addresses

main() void func(int *num)

{ {
int arr[5] ={1, 2, 3, 4, 5}; printf("%d", *num);
func(&arr[3]); }
}

Passing the entire array

main() void func(int arr[5])
{ {
int arr[5] ={1, 2, 3, 4, 5}; int i;
func(arr); for(i=0;i<5;i++)
} printf("%d", arr[i]);
}
void func(int []);
main()
{
int i, arr[6]={1,2,3,4,5,6};
func(arr);
printf(“Contents of array are now: “);
for(i=0; i<6; i++)
printf(“%d”,arr[i]);
printf(“/n”);
}

void func(int val[])

{
int sum=0,i;
for(i=0;i<6;i++)
{
val[i]=val[i]*val[i];
sum+=val[i];
}
printf(“The sum of squares = %d\n”, sum);
}
Output:

The sum of squares = 91

Contents of array are now: 1 4 9 16 25 36
 Two-dimensional Arrays
A two-dimensional array is specified using two subscripts where one
subscript denotes row and the other denotes column.
A two-dimensional array is an array of one-dimensional arrays in C which is
declared as:
data_type array_name[row_size][column_size];

Therefore, a two-dimensional m×n array is an array that contains m×n data

elements and each element is accessed using two subscripts, i and j, where
i<=m and j<=n:
int marks[3][5];
Col 0 Col 1 Col2 Col 3 Col 4
Rows/Cols
Row 0 Marks[0][0] Marks[0][1] Marks[0][2] Marks[0][3] Marks[0][4]
Row 1 Marks[1][0] Marks[1][1] Marks[1][2] Marks[1][3] Marks[1][4]
Row 2 Marks[2][0] Marks[2][1] Marks[2][2] Marks[2][3] Marks[2][4]
 Memory Representation of a 2D Array
There are two ways of storing a 2-D array in memory. The first way is row-
major order and the second is column-major order.
In the row-major order, the elements of the first row are stored before the
elements of the second and third rows. That is, the elements of the array
are stored row by row where n elements of the first row will occupy the
first nth locations.

(0,0) (0, 1) (0,2) (0,3) (1,0) (1,1) (1,2) (1,3) (2,0) (2,1) (2,2) (2,3)

In the column-major order, the elements of the first column are stored
before the elements of the second and third columns. That is, the elements
of the array are stored column by column where n elements of the first
column will occupy the first nth locations.

(0,0) (1,0) (2,0) (3,0) (0,1) (1,1) (2,1) (3,1) (0,2) (1,2) (2,2) (3,2)
 Initializing Two-dimensional Arrays
A two-dimensional array is initialized in the same way as a 1-D array is

initialized.

For example,

int marks[2][3]={90, 87, 78, 68, 62, 71};

int marks[2][3]={{90,87,78},{68, 62, 71}};

Passing 2D Arrays to Functions
There are three ways of passing two-dimensional arrays to a function.

2D Array for Inter Function Communication

Passing individual elements Passing a row Passing the entire 2D array

Passing individual elements

main() void func(int num)
{ {
int arr[2][3] ={{1, 2, 3}, {4, 5, 6}}; printf("%d", num);
func(arr[1][3]); }
}
Passing a row
main() void func(int arr[])
{ {
int arr[2][3]= ( {1, 2, 3}, {4, 5, 6} }; int i;
func(arr[1]); for(i=0;i<3;i++)
} printf("%d", arr[i] * 10);
}

Passing the entire array

main() void func(int arr[][])
{ {
int arr[2][3]= ( {1, 2, 3}, {4, 5, 6} }; int i;
func(arr); for(i=0;i<2;i++)
} for(j=0;j<3;j++)
printf("%d", arr[i][j]);
}
 Pointers and Arrays
The name of an array is a pointer that points to the first element of the array.

int *ptr;
ptr = &arr[0];

If pointer variable ptr holds the address of the first element in the array, then
the address of the successive elements can be calculated by writing ptr++.

int *ptr = &arr[0];

ptr++;
printf (“The value of the second element in the array is %d”, *ptr);
 Arrays of Pointers
An array of pointers can be declared as:
int *ptr[10];
The above statement declares an array of 10 pointers where each of the
pointer points to an integer variable. For example, look at the code given
below. int *ptr[10];
int p=1, q=2, r=3, s=4, t=5;
Can you tell what will be the output
ptr[0]=&p;
of the following statement?
ptr[1]=&q;
printf(“\n %d”, *ptr[3]);
ptr[2]=&r;
ptr[3]=&s;
ptr[4]=&t
The output will be 4 because ptr[3] stores the address of integer
variables and *ptr[3] will therefore print the value of s that is 4.
 Pointers and 2D Arrays
Individual elements of the array mat can be accessed using either:
mat[i][j] or *(*(mat + i) + j) or*(mat[i]+j);

Pointer to a one-dimensional array can be declared as:

int arr[ ]={1,2,3,4,5};
int *parr;
parr=arr;

Similarly, pointer to a two-dimensional array can be declared as:

int arr[2][2]={{1,2},{3,4}};
int (*parr)[2];
parr=arr;
 Multi-dimensional Arrays
A multi-dimensional array is an array of arrays.
We have one index in a single-dimensional array, and two indices in a
two-dimensional array, in the same way we have n indices in a n-
dimensional array or multi-dimensional array.

In a multi-dimensional array, a particular element is specified by using n

subscripts as A[I1][I2][I3]…[In], where
I1<=M1 I2<=M2 I3 <= M3 ……… In <= Mn
 Initializing Multi-dimensional Arrays

A multi-dimensional array is declared and initialized the same way as we

declare and initialize one- and two-dimensional arrays.

A pointer to a three-dimensional array can be declared as:

int arr[2][2][2]={1,2,3,4,5,6,7,8};
int (*parr)[2][2];
parr=arr;

We can access an element of a three-dimensional array by writing:

arr[i][j][k]= *(*(*(arr+i)+j)+k)