Unit I

1
INTRODUCTION TO DATA
STRUCTURES
Unit Structure :

1.0 Objectives
1.1 Data and Information
1.2 Data Structure
1.3 Classification of Data Structure- Primitive Data types, Abstract
Data types, Data type VS File organization
1.4 Operation on Data Structure
1.5 Importance of Algorithm Analysis
1.6 Complexity of an Algorithm- Asymptotic Analysis and
Notations, Big O Notation, Big Omega Notation, Big Theta
Notation, Rate of Growth and Big O Notation
1.7 Summary
1.8 References
1.9 Questions

1.0 OBJECTIVES

At the end of this unit, the student will be able to

Explain the use of data structure in computers
Differentiate between the different types of data structures
Illustrate the concept of asymptotic notations
Understand the operations of data structures

1.1 DATA AND INFORMATION

1 Data Structure is one of the most fundamental subject in computer

science and in-depth understanding of this word i.e Data +
Structure is very important especially when you are developing a
programs for building efficient systems software and applications.
2 Definition- In Computer Science, a data structure is a data
organization, management and storage format that enables efficient
access and modification. In simple words It is a way in which data
is stored on a computer.
3 Why do we need Data Structures?
3.1 Data structure is a particular way of storing and organizing
information in a computer so that it can be retrieved and used most
productively
3.2 As each data structure allow data to be stored in specific manner.
1
3.3 Data Structure allows efficient data search and retrieval.
3.4 Specific data structure are decided to work for specific problems.
3.5 It allows to manage large amount of databases and indexing
services such as hash table.
4 Examples of Data Structure are Digital Dictionary, Google Map etc
5 For eg Array is a Data Structure- will explain with preceded
diagram int number[4]={10,20,30,40}; Here one dimensional array
is created which will stored in RAM in rows and column format
and that resembles array as a Data structure where 10,20,30,40
represents as value.
6 What is Data + Information in terms of Data Structure
6.1 Data means an individual unit that contains raw materials which do
not carry any specific meaning, Whereas Information means is a
group of data that collectively carries a logical meaning.
6.2 For eg if we refer to above example of Array, each array value
which is stored in row and column is belongs to data part and
complete array values can be retrieved at a time is nothing but
information, on that note exact difference between data and
information is data does not depend on information, but
information depend on data.
6.3 Table 1 Shows difference between Data & Information

Points of Data Information

Comparison
Meaning Data means raw facts Facts, Concerning a
gathered about someone particular event or subject,
or something which is which are refined by
bare and random processing is called
information
What is it? It is just text and It is refined data
numbers
Based On Records and Observation Analysis
Form Unorganized Organized
Useful May or May not be Always
useful
Specific No Yes
Dependency Does not depend on Without data, information
information cannot be processed
Table 1

1.2 DATA STRUCTURE

1. What is binding between Algorithm, Program and Data Structure?

1.1 Algorithm- It outline, the essential of a computational procedure,
step by step instructions.

2
1.2 Program- A implementation of algorithm in some programming
language.
1.3 Data Structure- Organization of data needed to solve the program
1.4 for eg Write a program to print 10 numbers

Algorithm would be
Step 1 Take a range of values in a variable A, nothing but an Array
Data Structure
Step 1 Assign a Value to an Array A Such as A[1,2,3,4,5,6,7,8,9,10]
Step 2 Apply loop to print values of Array
Program
# include<stdio.h>
#include<conio.h>
Void main
{
int a[10],i;
for(i=0;i<10;i++)
{
Printf(“The value of is “,i);
}
}
Data structure – here array is one type of data structure used here

1.5 Difference between Algorithm and Pseudocode

Table 2 Represents difference between Algorithm and Pseudocode

Sr.No Algorithm Pseudocode

1 Systematic logical approach It is one of the methods
which is a well-defined, step- which can be used to
by-step procedure that allows represent an algorithm for a
a computer to solve a program
problem
2 Algorithms can be expressed Pseudocode allows you to
using natural language, include several control
flowcharts etc structures such as while, if-
then-else, Repeat-until, for
and case which is present in
many high-level languages
Table 2

1.6 Data Structure mainly specifies the following four things

Organization of Data
Accessing /methods
Degree of Associativity
Processing alternatives for information

1.7 To study Data structure in basic terms covers the following points
Amount of memory require to store
Amount of time require to process
Representation of data in memory
Operations performed on that data
3
1.3 CLASSIFICATION OF DATA STRUCTURE-
PRIMITIVE DATA TYPES, ABSTRACT DATA
TYPES, DATA TYPE VS FILE ORGANIZATION

Fig. 1 Classification of Data Structure

1 Data structures are normally classified in to two broad categories

1 Primitive Data Structures
2 Non-Primitive Data Structure
2 Data types- A particular kind of data item, as defined by the values
it can take, the programming language used or the operations that
can be performed on it.
3 Primitive Data Structure
3.1 Primitive data structure are basic structures and are directly
operated upon by machine instructions.
3.2 Primitive data structures have different representations on
different computers.
3.3 Integers, floats, character and pointers are examples of
primitive data structures.
3.4 These data types are available in most programming languages
as built in type
3.4.1 Integer- It is a data type which allows all values without
fraction part. We can use it for whole numbers.
3.4.2 Float- It is a data type which use for storing fractional
numbers.
3.4.3 Character- It is a data type which is used for character values.
3.4.5 Pointer- A variable that holds memory address of another
variable are called pointer.
4 Non Primitive Data type
4.1 These are more sophisticated data structures
4.2 These are derived from primitive data structures.
4.3 The non-primitive data structures emphasize on structuring of a
group of homogeneous or heterogeneous data items.

4
 4.4 Example of non-primitive data types are Array, List and Files
etc.
4.5 A Non-primitive data type is further divided in to Linear and
Non-Linear data structure
1 Array- An array is a fixed size sequenced collection of elements
of the same data type.
2 List- An ordered set containing variable number of elements of
the same data type .
3 File- A file is a collection of logically related information. It can
be viewed as a large list of records consisting of various fields.
5 Linear Data Structures
5.1 A data structure is said to be linear, if its elements are
connected in linear fashion by means of logically or in sequence
memory locations.
5.2 There are two ways to represent a linear data structure in
memory,
1 Static Memory Allocation
2 Dynamic Memory Allocation
5.3 The possible operations on the linear data structure are-
Traversal, insertion, Deletion, Searching, Sorting and Merging.
5.4 Examples of Linear Data Strictures are Stack and Queue
5.4.1 Stack- It is a data structure in which insertion and deletion
operation are performed a one end only. The insertion operation is
referred to as “PUSH” and deletion operation is referred to as
“POP” operation. Stack is also called as Last in First Out(LIFO)
data structure.
5.4.2 Queue- The data structure which permits the insertion at one
end and deletion at another end known as queue. End at which
deletion is occurs is known as FRONT end and another end at
which insertion occurs as REAR end. It is also called as First in
First Out (FIFO) structure.
6 Non Linear data Structures
6.1 These are those data structure in which data items are not
arranged in a sequence.
6.2 Examples of Non-Linear Data Structure are Tree and Graph.
6.3 Tree- A tree can be defined as finite set of data items(nodes) in
which data items are arranged in branches and sub branches
according to requirement. It represent the hierarchical relationship
between various elements. Tree consist of nodes connected by
edge, the node represented by circle and edge lives connecting to
circle.
6.4 Graph- Graph is a collection of nodes(information) and
connecting edges(logical relation) between nodes. A tree can be
viewed as restricted graph. Graph have many types like un-directed

5
 graph, directed graph, mixed graph, multi graph, simple graph, null
graph, weighted graph.
7 Table 3 Shows difference between Linear and Non Linear Data
Structure

Sr. No Linear Data Structure Non-Linear Data Structure

1 Every item is related to Every item is attached with
its previous and next many other items
time
2 Data is arranged in Data is not arranged in sequence
linear sequence
3 Data items can be Data cannot be traversed in a
traversed in a single single run.
run.
4 Eg Array, Stacks, Eg Tree, Graph
linked list, queue
5 Implementation is easy Implementation is difficult
Table 3
8 Abstract Data type (ADT)- is a type for objects whose behaviour is
defined by a set of value and a set of operations.
8.1 The definition of ADT only mentions what operations are to be
performed but not how these operations will be implemented.
8.2 It does not specify how data will be organized in memory and
what algorithms will be used for implementing the operations.
8.3 It is called “abstract” as it gives an implementation-independent
view. The process of providing only the essentials and hiding the
details is known as abstraction.

Fig 2 ADT
8.4 for eg Stack ADT
1 In Stack ADT implementation instead of data being stored in
each node, the pointer to data is stored.
2 The program allocates memory for the data and address is passed
to the stack ADT.

6
 Fig 3 Stack as ADT

3 The head node and the data nodes are encapsulated in the ADT.
The calling function can only see the pointer to the stack.
4 The stack head structure also contains a pointer to top and
count of number of entries currently in stack. As Push(),
pop(),peek(),size(),isempty(),isfull() is already implemented in
STACK ADT, only programmer has to use this function for
implementing program on stack
9 Data Type V/s File Organization- Data type is A particular kind of
data item, as defined by the values it can take, the programming
language used or the operations that can be performed on it,
whereas File organization means how data type values are arranged
or organized in file.

1.4 OPERATION ON DATA STRUCTURE

1 Design of efficient data structure must take operations to be

performed on the data structures in to account. The most
commonly used operations on data structure are broadly divided in
to following types as follows
1.1 Create – The create operation results in reserving memory for
program elements. This can be done by declaration statement.
Creation of data structure may take place either during compile
time or run time. Malloc() function of C language is used for
creation. For eg ptr=(int*) malloc(100*sizeof(int)) , this syntax
will allocate 400 bytes of memory and the pointer ptr holds the
address of the first byte in the allocated memory.
1.2 Destroy- This operation destroys memory space allocated for
specified data structure. Free() function of C language is used
to destroy data structure. For eg syntax of using free() is only
write free(ptr).
1.3 Selection- Selection operation deals with accessing a particular
data within a data structure. For eg Pseudocode represent below
will show how selection works
If student’s grade is greater than or equal to 60 then
Print passed
Else
Print “failed”

7
 In above pseudocode, all students are not passed, only that students
are selected which are above 60. So this is selection operation.
1.4 Updation- It updates or modifies the data in the data structure
1.5 Searching-It finds the presence of desired data item in the list
of data items, it may also find the locations of all elements that
satisfy certain conditions.
1.6 Sorting- It is a process of combining the data items of two
different sorted list in to a single list.
1.7 Merging- It is a process of combining the data items of two
different sorted list in to a single sorted list.
1.8 Splitting- It is a process of partitioning single list to multiple
list.
1.9 Traversal- It is a process of visiting each and every node of a
list in systematic manner.

1.5 IMPORTANCE OF ALGORITHM ANALYSIS

1 Algorithm
1.1 An essential aspect to data structures is algorithms.
1.2 Data Structures are implemented using algorithms.
1.3 An algorithm is a procedure that you can write as a C function or
program, or any other language.
1.4 An algorithm states explicitly how the data will be manipulated.
2 Algorithm Efficiency
2.1 Some algorithms are more efficient than others. We would prefer
to choose an efficient algorithm, so it would be nice to have
metrics for comparing algorithm efficiency.
2.2 The complexity of an algorithm is a function describing the
efficiency of the algorithm in terms of the amount of data the
algorithm must process.
2.3 Usually there are natural units for the domain and range of this
function. There are two main complexity measure of the efficiency
of an algorithm.
3 Time Complexity
3.1 It is a function describing the amount of time an algorithm takes in
terms of the amount of input to the algorithm.
3.2 Time can mean the number of memory accesses performed, the
number of comparisons between integers, the number of times
some inner loop is executed or some other natural unit related to
the amount of real time the algorithm will be.
4 Space complexity
4.1 It is a function describing the amount of memory space an
algorithm takes in terms of the amount of input to the algorithm.
4.2 We always speak of “extra” memory needed, not counting the
memory needed to store the input itself. Again we use natural but
fixed-length units to measure this.
8
4.3 We can use bytes, but it's easier to use, say, number of integers
used, number of fixed-sized structures, etc. In the end, the function
we come up with will be independent of the actual
number of bytes needed to represent the unit.
4.4 It is sometimes ignored because the space used is minimal and/or
obvious, but sometimes it becomes as important an issue as time.
5 Worst Case Analysis
5.1 In the worst case analysis, we calculate upper bound on running
time of an algorithm. We must know that causes maximum number
of operations to be executed.
5.2 For Linear search, the worst case happens when the element to be
searched is not present in the array.
5.3 When X element is not present, the search() functions compares it
with all the elements of array[] one by one. So, the worst case time
complexity of linear search would be.
6 Average Case Analysis
6.1 In average case analysis, we take all possible inputs and calculate
computing time for all of the inputs.
6.2 Add all the calculated values and divide the obtained sum by total
number of inputs.
6.3 For the linear search problem, let us assume that all cases are
uniformly distributed. So we sum all the cases and divide the sum
by(n+1).
7 Best Case Analysis
7.1 In the best case analysis, we calculate lower bound on running time
of an algorithm. We must know the causes minimum number of
operations to be executed.
7.2 In the linear search problem, the best case occurs when x is present
at the first location.

1.6 COMPLEXITY OF AN ALGORITHM-

ASYMPTOTIC ANALYSIS AND NOTATIONS, BIG O
NOTATION, BIG OMEGA NOTATION, BIG THETA
NOTATION, RATE OF GROWTH AND BIG O
NOTATION

1 Asymptotic notations are the mathematical notations used to describe

the running time of an algorithm when the input tends towards a
particular value or a limiting value.

2 For example- In bubble sort, when the input array is already sorted,
the time taken by the algorithm is linear i.e the best case.

3 But, when the input array is in reverse condition, the algorithm takes
the maximum time (quadratic) to sort the elements i.e the worst case.

9
4 When the input array is neither sorted nor in reverse order, then it
takes average time. These durations are denoted using asymptotic
notations.

5 There are mainly three asymptotic notaions

5.1 Big-O Notation
5.2 Omega Notation
5.3 Theta Notation

6 Big-O Notation(O-Notation)
6.1 Big-O notation represents the upper bound of the running time of
an algorithm. Thus, it gives the worst-case complexity of an algorithm.

6.2 O(g(n)) = { f(n): there exist positive constants c and

n0
such that 0 f(n) cg(n) for all n n0 }
The above expression can be described as a function f(n) belongs to the
set O(g(n)) if there exists a positive constant c such that it lies between
0 and cg(n), for sufficiently large n.

6.3 For any value of n, the running time of an algorithm does not cross
the time provided by O(g(n)).

6.4 Since it gives the worst-case running time of an algorithm, it is

widely used to analyze an algorithm as we are always interested in the
worst-case scenario.

Fig 4 Big-O Notation

7Omega Notation( -Notation)

10
7.1 Omega notation represents the lower bound of the running time of
an algorithm. Thus it provides the best case complexity of an
algorithm.

7.2 (g(n)) = { f(n): there exist positive constants c and n0

such that 0 cg(n) f(n) for all n n0 }
The above expression can be described as a function f(n) belongs to the
set O(g(n)) if there exists a positive constant c such that it lies above
cg(n), for sufficiently large n.

7.3 For any value of n, the minimum time required by the

algorithm is given by omega (g(n)).

Fig 5 Omega Notation where omega gives the lower bound of a

function

8 Theta Notation( -Notation)

8.1 Theta notation encloses the function from above and below. Since
it represents the upper and the lower bound of the running time of
an algorithm, it is used for analyzing the average-case complexity
of an algorithm.
8.2 (g(n)) = { f(n): there exist positive constants c1, c2 and n0
such that 0 c1g(n) f(n) c2g(n) for all
n n0 }
The above expression can be described as a function f(n) belongs
to the set (g(n)) if there exists positive constant c1 and c2 such
that it can be sandwiched between c1g(n) and c2g(n), for
sufficiently large n.

11
8.3If a function f(n) lies any where in between c1g(n) and c2g(n) for
all n>=n0, then f(n) is said to be asymptotically tight bound.

Fig 6 Theta Notation where it gives the function within constant

factors

9 Properties of Asymptotic Notations

9.1 General Properties- If f(n) is O(g(n)) then a*f(n) is also O(g(n)) ;
where a is a constant.
Example: f(n) = 2n²+5 is O(n²)
then 7*f(n) = 7(2n²+5) = 14n²+35 is also O(n²) .
Similarly this property satisfies for both and notation. We can
say - If f(n) is (g(n)) then a*f(n) is also (g(n)) ; where a is a
constant. If f(n) is (g(n)) then a*f(n) is also (g(n)) ; where a is a
constant.

9.2 Transitive Properties

If f(n) is O(g(n)) and g(n) is O(h(n)) then f(n) = O(h(n)) . Example: if
f(n) = n, g(n) = n² and h(n)=n³ n is O(n²) and n² is O(n³) then n is O(n³)

9.3 Reflexive Properties

Reflexive properties are always easy to understand after transitive. If
f(n) is given then f(n) is O(f(n)). Since maximum value of f(n) will be
f(n) itself Hence x = f(n) and y = O(f(n) tie themselves in reflexive
relation always.

12
Example: f(n) = n² ; O(n²) i.e O(f(n) Similarly this property satisfies
for both and notation.

9.4 Symmetric Properties

If f(n) is (g(n)) then g(n) is (f(n)) . Example: f(n) = n² and g(n) =
n² , then f(n) = (n²) and g(n) = (n²) . This property only satisfies for
theta notation.

9.5 Transpose symmetric properties

If f(n) is O(g(n)) then g(n) is (f(n)). Example: f(n) = n , g(n) =
n² ,then n is O(n²) and n² is (n) . This property only satisfies for
Omega and O notation.

10 Practice Problem-In this problem you will compute the asymptotic

time complexity of the following divide-and-conquer algorithm.
You may assume that n is a power of 2. (NOTE: It doesn't matter
what this does!)

float useless(A){
n = A.length;
if (n==1){
return A[0];
}
let A1,A2 be arrays of size n/2
for (i=0; i <= (n/2)-1; i++){
A1[i] = A[i];
A2[i] = A[n/2 + i];
}
for (i=0; i<=(n/2)-1; i++){
for (j=i+1; j<=(n/2)-1; j++){
if (A1[i] == A2[j])
A2[j] = 0;
}
}

b1 = useless(A1);
b2 = useless(A2);
return max(b1,b2);
}

The solution to above problem is

Clearly T(1) = Theta(1). The first loop used for splitting has time
complexity

Theta(n) and the second has time complexity Theta(n^2). There are 2
recursive calls of size n/2. Finally constant time (Theta(1)) is spent
combining. Hence we get the recurrence.

T(1) = Theta(1)
T(n) = 2 T(n/2) + Theta(n^2) for n >= 2

By the master method we get that T(n) = Theta(n^2). Hence this given
algorithm is a Theta(n^2) algorithm.

13
1.7 SUMMARY OF CHAPTER

In this chapter we discuss about what is difference between Data

and information.
This chapter also gives definition of Data structure along with
operation on Data Structure like Insertion, search, updation,
deletion.
Also seen the concept of why algorithm analysis is important with
respect to best case, worst case and average case analysis and with
respect to time and space complexity.
Asymptotic notation can be illustrated in this chapter with function
growth rate and example and also discussed usage of BigO, Theta
and Omega in finding out algorithm complexity.

1.8 REFERENCES

Textbook
1 An Introduction to Data Structure with Applications, Jean – Paul
Tremblay and Paul Sorenson Tata MacGraw Hill 2 nd 2007.
2 Schaum’s Outlines Data structure Seymour Lipschutz Tata McGraw
Hill 2 nd 2005.

Useful Links
1 Nptel Course of Data Structure-
https://nptel.ac.in/courses/106/102/106102064/

1.9 MISCELLANEOUS QUESTIONS

Q1 Discuss different types of Data Structures

Q2 Define Data Structure and its importance
Q3 What is Best case, Average Case and Worst case w.r.t to algorithm
Q4 Compare and Contrast between Big O notation, Theta Notation and
Omega Notation
Q5 Difference between Linear and Non Linear Data Structure

14
 2
ARRAY
Unit Structure :

2.0 Objectives
2.1 Introduction
2.2 One Dimensional Array- Memory Representation, Traversing,
Insertion, Deletion, Searching, Sorting, Merging of Arrays.
2.3 Multidimensional Arrays- Memory Representation, General
Multidimensional arrays
2.4 Sparse Arrays- Sparse Matrix, Memory Representation of special
kind of matrices
2.5 Advantages and Limitations of Arrays
2.6 Summary
2.7 References
2.8 Questions

2.0 OBJECTIVES

At the end of this unit, the student will be able to

Describe the memory representation of one dimensional array and the
operation on array.
Illustrate the concept of M-Dimensional array.
Explain the need of Sparse array.
Compare and constrast between different types of arrays.

2.1 INTRODUCTION OF ARRAYS

An array is a data structure used to process multiple elements with the

same data type when a number of such elements are known.
Arrays form an important part of almost all-programming languages.
It provides a powerful feature and can be used as such or can be used
to form complex data structures like stacks and queues.
An array can be defined as an infinite collection of
homogeneous(similar type) elements.
This means that an array can store either all integers, all floating point
numbers, all characters, or any other complex data type, but all of
same type.
Arrays are always stored in consecutive memory locations.
Types of Arrays

15
There are two types of arrays
One Dimensional Arrays
Two Dimensional Arrays

2.2 ONE DIMENSIONAL ARRAY- MEMORY

REPRESENTATION, TRAVERSING, INSERTION,
DELETION, SEARCHING, SORTING, MERGING OF
ARRAYS

1. One Dimensional Arrays

A one-dimensional array is one in which only one subscript
specification is needed to specify a particular element of the array.
A one-dimensional array is a list of related variables. Such lists are
common in programming.
One-dimensional array can be declared as follows :
Data_type var_name[Expression];

2. Initializing One-Dimensional Array

2.1 ANSI C allows automatic array variables to be initialized in

declaration by constant initializers as we have seen we can do for scalar
variables.

2.2 These initializing expressions must be constant value; expressions with

identifiers or function calls may not be used in the initializers.

2.3 The initializers are specified within braces and separated by commas
as shown in below declarations
int ex[5] = { 10, 5, 15, 20, 25} ;
char word[10] = { 'h', 'e', 'l', 'l', 'o' } ;

2.4 Example
// Program to print the element of Array

#include <stdio.h>
int main()
{
/*an array with 5 rows and 2 columns*/
int a[5][2] = {{0,0},{1,2},{2,4},{3,6},{4,8}};
int i,j;
/* Output each array elements value*/
for(i=0; i<5; i++);
{
for(j=0; j<2; j++);
{
printf("a[%d][%d]=%d",i,j,a[i][j]);
}
}
return 0;
16
}
Output
a[0][0] = 0
a[0][1] = 0
a[1][0] = 1
a[1][1] = 2
a[2][0] = 2
a[2][1] = 4
a[3][0] = 3
a[3][1] = 6
a[4][0] = 4

3Memory Representation of 1-D array:

3.1 One-dimensional arrays are allocated in a contiguous block of
memory.
3.2 All the elements are stored next to each other.
3.3 Example: int a[4]= {10,20,30,40}
3.4 Each element in an array has a unique subscript value from 0 to size of
array.
3.5 Example: a[0] = 10 , a[1]=20 , a[3] = 30 , a[4] = 40
3.6 As there are 4 integer elements , the array occupies total of 4*2=8
bytes
3.7 let the memory location start at value 100, so the memory
representation will look like as depict in below diagram

Fig 1 Memory Representation of 1D Array

4.Operation of One Dimensional Array
4.1 Traversing
1 In traversing operation of an array, each element of an array is accessed
exactly for once for processing. This is also called visiting of an array.
2 Let LA is a Linear Array (unordered) with N elements.
//Write a Program which perform traversing operation.

Note- Use online compiler GDB compiler for running this program

#include <stdio.h>
int main()
{
int i,n; //Declaration of Variable used for inputing Value and for
iteration
17
 printf("Enter the size of array");
scanf("%d",&n);
int LA[n];//Declaration of array
printf("The array elements are:\n");
for(i=0;i<n;i++)
{
scanf("%d", &LA[i]);
}

for(i=0; i<n; i++)

{
printf("LA[%d] = %d \n",i,LA[i]);
}
return 0;
}
Output
Enter the size of array 5
5
The array elements are:
1
2
3
4
5
LA[0] = 1
LA[1] = 2
LA[2] = 3
LA[3] = 4
LA[4] = 5

4.2 Insertion Operation

1.Insert operation is to insert one or more data elements into an array.
Based on the requirement, new element can be added at the beginning, end
or any given index of array.
2. Here, we see a practical implementation of insertion operation, where
we add data at the end of the array.
3. Example
//Write a program to perform Insertion operation.
//Program for inserting an Array
#include <stdio.h>
void main()
{
int LA[] = {5,6,7,8,9};// Declaration & Initialization of Array
int item = 4, k = 0, n = 5; //Iterator Variable
int i = 0, j = n;
printf("The original array elements are:\n");
for(i = 0; i<n; i++)
{
18
 printf("LA[%d] = %d \n", i, LA[i]);
}
n = n + 1;
while( j >= k)
{
LA[j+1] = LA[j];
j = j - 1;
}
LA[k] = item;
printf("The array elements after insertion:\n");
for(i = 0; i<n; i++)
{
printf("LA[%d] = %d \n", i, LA[i]);
}
}
Output
The original array elements are:
LA[0] = 5
LA[1] = 6
LA[2] = 7
LA[3] = 8
LA[4] = 9
The array elements after insertion:
LA[0] = 4
LA[1] = 5
LA[2] = 6
LA[3] = 7
LA[4] = 8
LA[5] = 9

4.3 Deletion Operation

1 Deletion refers to removing an existing element from the array and re-
organizing all elements of an array.
2 Example
Consider LA is a linear array with N elements and K is a positive integer
such that K<=N.
//Write a program to perform deletion operation.

//Program for deleting an element from an array

#include <stdio.h>
void main()
{
int LA[] = {1,2,3,4,5};// Declararing and Initialization of Array
int k = 3, n = 5;// Set the range variables
int i, j; //Declare the Iterator
printf("The original array elements are:\n");
for(i = 0; i<n; i++)
{
19
 printf("LA[%d] = %d \n", i, LA[i]);
}
j = k;
while( j < n)
{
LA[j-1] = LA[j];
j = j + 1;
}
n = n -1;
printf("The array elements after deletion:\n");
for(i = 0; i<n; i++)
{
printf("LA[%d] = %d \n", i, LA[i]);
}
}
Output
The original array elements are:
LA[0] = 1
LA[1] = 2
LA[2] = 3
LA[3] = 4
LA[4] = 5
The array elements after deletion:
LA[0] = 1
LA[1] = 2
LA[2] = 4
LA[3] = 5

4.4Update Operation
1.Update operation refers to updating an existing element from the array at
a given index.
2.Example
Consider LA is a linear array with N elements and K is a positive integer
such that K<=N.

//Write a program to perform updation operation.

#include <stdio.h>
void main()
{
int LA[] = {10,11,12,13,14};
int k = 3, n = 5, item = 15;
int i, j;
printf("The original array elements are:\n");
for(i = 0; i<n; i++)
{
printf("LA[%d] = %d \n", i, LA[i]);
}
LA[k-1] = item;
20
 printf("The array elements after updation:\n");
for(i = 0; i<n; i++)
{
printf("LA[%d] = %d \n", i, LA[i]);
}
}
Output
The original array elements are:
LA[0] = 10
LA[1] = 11
LA[2] = 12
LA[3] = 13
LA[4] = 14
The array elements after updation:
LA[0] = 10
LA[1] = 11
LA[2] = 15
LA[3] = 13
LA[4] = 14

4.5 Searching an Element in an Array

1 Using searching operation on array, an element is searched in an array
using key as variable . If element is found in an array at particular location
means element is present, if not means elements is not present in an array.
2 There are two types of Search methods a)Linear Search b) Binary search
3 For Eg Write a program to perform linear search on given array

//Write a program to perform Search operation.

#include <stdio.h>
int main()
{
int a[10],i,n,key;
printf("Enter size of the array : ");
scanf("%d", &n);
printf("Enter elements in array : ");
for(i=0; i<n; i++)
{
scanf("%d",&a[i]);
}
printf("Enter the key : ");
scanf("%d", &key);

for(i=0; i<n; i++)

{
if(a[i]==key)
{
printf("element found ");
return 0;
21
 }

}
printf("element not found");
}
//output
Enter size of the array : 5
Enter elements in array : 1
2
3
4
5
Enter the key : 6
element not found

4.6 Sorting Operation in an array

1 With this operation, the array elements are ordered either in ascending or
descending order. There many sorting techniques, that you will study later
on. But overhere simple bubble sort technique is implemented
2 For eg Write a program for sorting elements in an array

//Write a program to perform Sort operation.

#include <stdio.h>
void main()
{
int i, j, a, n;

printf("Enter the value of N \n");

scanf("%d", &n);
int number[30];
printf("Enter the numbers \n");

for (i = 0; i < n; ++i)

scanf("%d", &number[i]);
for (i = 0; i < n; ++i)

for (j = i + 1; j < n; ++j)

if (number[i] > number[j])

22
 a = number[i];

number[i] = number[j];

number[j] = a;
}

}
printf("The numbers arranged in ascending order are given below
\n");
for (i = 0; i < n; ++i)
printf("%d\n", number[i]);

}
//output
Enter the value of N
5
Enter the numbers
5
4
3
2
1
The numbers arranged in ascending order are given below
1
2
3
4
5

4.6 Merging Operation in an Array

1 With this operation, the two arrays be merged together in to an one
array.
2 For eg Write a program to merge two array in to one

//Write a program to perform Merge operation.

#include<stdio.h>
int main()
{
int size1, size2, i, k, merge[100];
printf("Enter Array 1 Size: ");
scanf("%d", &size1);
printf("Enter Array 1 Elements: ");
int arr1[50];
for(i=0; i<size1; i++)
{
scanf("%d", &arr1[i]);
merge[i] = arr1[i];
23
 }
k = i;
printf("\nEnter Array 2 Size: ");
scanf("%d", &size2);
int arr2[50];
printf("Enter Array 2 Elements: ");
for(i=0; i<size2; i++)
{
scanf("%d", &arr2[i]);
merge[k] = arr2[i];
k++;
}
printf("\nThe new array after merging is:\n");
for(i=0; i<k; i++)
printf("%d ", merge[i]);
return 0;
}
//output
Enter Array 1 Size: 5
Enter Array 1 Elements: 1
2
3
4
5
Enter Array 2 Size: 5
Enter Array 2 Elements: 6
7
8
9
10
The new array after merging is:
1 2 3 4 5 6 7 8 9 10

2.3 MULTIDIMENSIONAL ARRAYS- MEMORY

REPRESENTATION, GENERAL MULTIDIMENSIONAL
ARRAYS

Two dimensional arrays are also called table or matrix, two

dimensional arrays have two subscripts.
Two dimensional array in which elements are stored column by
column is called as column major matrix.
Two dimensional array in which elements are stored row by row is
called as row major matrix.
First subscript denotes number of rows and second subscript denotes
the number of columns.

24
 The simplest form of the Multi Dimensionl Array is the Two
Dimensionl Array. A Multi Dimensionl Array is essence a list of One
Dimensionl Arrays.

Two dimensional arrays can be declared as follows :

int int_array[10] ; // A normal one dimensional array
int int_array2d[10][10] ; // A two dimensional array
Initializing a Two Dimensional Array
A 2D array can be initialized like this :
int array[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 } ;

Program
#include <stdio.h>
void printarr(int a[][]);
void printdetail(int a[][]);
void print_usingptr(int a[][]);
main()
{
int a[3][2]; \ A
for(int i = 0;i<3;i++)
for(int j=0;j<2 ;j++)
{
{
a[i]=i;
}
}
printdetail(a);
}
void printarr(int a[][])
{
for(int i = 0;i<3;i++)
for(int j=0;j<2;j++)
{
{
printf("value in array %d,a[i][j]);
}
}
}
void printdetail(int a[][])
{
for(int i = 0;i<3;i++)
for(int j=0;j<2;j++)
{
{
printf( "value in array %d and address is %8u, a[i][j],&a[i][j]);
}
}
}
void print_usingptr(int a[][])
{
int *b; \ B
b=a; \ C
for(int i = 0;i<6;i++) \ D
{
25
 printf("value in array %d and address is %16lu,*b,b);
b++; // increase by 2 bytes \ E
}
}

Explanation
Statement A declares a two-dimensional array of the size 3 × 2.
The size of the array is 3 × 2, or 6.
Each array element is accessed using two subscripts.
You can use two for loops to access the array. Since i is used for
accessing a row, the outer loop prints elements row-wise, that is, for
each value of i, all the column values are printed.
You can access the element of the array by using a pointer.
Statement B assigns the base address of the array to the pointer.
The for loop at statement C increments the pointer and prints the value
that is pointed to by the pointer. The number of iterations done by the
for loop, 6, is equal to the array.
Using the output, you can verify that C is using row measure form for
storing a two dimensional array.

2.4 SPARSE ARRAYS- SPARSE MATRIX, MEMORY

REPRESENTATION OF SPECIAL KIND OF MATRICES

1 A sparse array is an array of data in which many elements have a value

of zero. This is in contrast to a dense array, where most of the elements
have non-zero values or are “full” of numbers. A sparse array may be
treated differently than a dense array in digital data handling.

2 Sparse Matrix Representation

A sparse matrix can be represented by using TWO representations, those
are as follows...
1. Triplet Representation (Array Representation)
2. Linked Representation

3Triplet Representation (Array Representation)

3.1 In this representation, we consider only non-zero values along with
their row and column index values. In this representation, the 0th row
stores the total number of rows, total number of columns and the total
number of non-zero values in the sparse matrix. For example, consider a
matrix of size 5 X 6 containing 6 number of non-zero values. This matrix
can be represented as shown in the image

26
 Fig 1 Array Representation of Sparse Matrix

In above example matrix, there are only 6 non-zero elements ( those are 9,
8, 4, 2, 5 & 2) and matrix size is 5 X 6. We represent this matrix as shown
in the above image. Here the first row in the right side table is filled with
values 5, 6 & 6 which indicates that it is a sparse matrix with 5 rows, 6
columns & 6 non-zero values. The second row is filled with 0, 4, & 9
which indicates the non-zero value 9 is at the 0th-row 4th column in the
Sparse matrix. In the same way, the remaining non-zero values also follow
a similar pattern.

4 Linked Representation
4.1 In linked representation, we use a linked list data structure to represent
a sparse matrix. In this linked list, we use two different nodes
namely header node and element node. Header node consists of three
fields and element node consists of five fields as shown in the image.

Fig 2 Header and Element Node of Linked Representation

4.2 Consider the above same sparse matrix used in the Triplet
representation. This sparse matrix can be represented using linked
representation as shown in the below image.

27
 Fig 3 Linked Representation of Sparse Matrix

In the above representation, H0, H1,..., H5 indicates the header

nodes which are used to represent indexes. Remaining nodes are used to
represent non-zero elements in the matrix, except the very first node which
is used to represent abstract information of the sparse matrix (i.e., It is a
matrix of 5 X 6 with 6 non-zero elements). In this representation, in each
row and column, the last node right field points to its respective header
node.

2.5 ADVANTAGES AND LIMITATIONS OF ARRAYS

1 Advantages
1.1 Arrays represent multiple data items of the same type using a single
name.
1.2 Arrays allocate memory in contiguous memory locations for all its
elements. Hence there is no chance of extra memory being allocated in
case of arrays. This avoids memory overflow or shortage of memory in
arrays.
1.3 In arrays, the elements can be accessed randomly by using the index
number.
1.4 Using arrays, other data structures like linked lists, stacks, queues,
trees, graphs etc can be implemented.
1.5 Two-dimensional arrays are used to represent matrices.

2 Disadvantages
2.1 The number of elements to be stored in an array should be known in
advance.
2.2 An array is a static structure (which means the array is of fixed size).
Once declared the size of the array cannot be modified. The memory
which is allocated to it cannot be increased or decreased.

28
2.3 Insertion and deletion are quite difficult in an array as the elements are
stored in consecutive memory locations and the shifting operation is
costly.
2.4 Allocating more memory than the requirement leads to wastage of
memory space and less allocation of memory also leads to a problem.

2.6 SUMMARY OF CHAPTER

This chapter highlights the declaration of 1D array with the program

illustrating for operation on array like insertion, updation, deletion,
searching, sorting, merging.
Two D array is part of multidimensional array and explained through a
program on matrix.
Here we also did a discussion about types of Sparse matrix i.e Array
and Linked representation.
We seen some advantages and limitations of arrays.

2.7 REFERENCES

Textbook
1 An Introduction to Data Structure with Applications, Jean – Paul
Tremblay and Paul Sorenson Tata MacGraw Hill 2 nd 2007.
2 Schaum’s Outlines Data structure Seymour Lipschutz Tata McGraw Hill
2 nd 2005.

Useful Links
1 Nptel Course of Data Structure-
https://nptel.ac.in/courses/106/102/106102064/

2.8 MISCELLANEOUS QUESTIONS

Q1 Discuss various operation performed on an array?

Q2 List advantages and Disadvantages of Array?
Q3 Illustrate the concept of Sparse Matrix?
Q4 Define Array?

29
Unit II

30
For example:
Cat, Dog, Lion, Elephant
We can add more elements in the list at any place beginning, at
middle position or at end position.

A linked list is ordered collection of data in which each element

contains the data and link to its successor and predecessor.

3.2 CONCEPT ON LINKED LIST

A linked list is a non-sequential collection of data element. It is a

dynamic data structure. For every data element in a linked list, there is
an associated pointer that would give the memory location of the next
data element in the linked list.
The data elements in the linked list are not in consecutive memory
locations. They may be anywhere, but the accessing of these data
elements is easier as each data element contains the address of the next
data element.
It is a data Structure which consists of group of nodes that forms a
sequence.
It is very common data structure that is used to create tree, graph and
other abstract data types.
Linked list comprise of group or list of nodes in which each node have
link to next node to form a chain.

A linked list is a linear collection of data-elements, called

The linear order is maintained by pointers.

Data Address of next node

Fig.3.2.1.Address of Node

Advantages of Linked List:

Linked list is dynamic in nature which allocates the memory when
required.
Grow and shrink the linked list during run time
Memory Utilization
Insertion and Deletion Operations are quite easy

31
Disadvantages of Linked List:
Memory Usage-The memory is wasted as pointers require extra
memory for storage.
No element can be accessed randomly; it has to access each node
sequentially.
Time Consuming
Heap Space Restriction
Reverse Traversing is difficult.
Data accessing is very slow.
No cache Memory Support

Applications of Linked List:

In System Programming
In operating System
Used in radix and bubble sorting.
In a FAT file system, the metadata of a large file is organized as a
linked list of FAT entries.
To model the different ADT for other data structure as like stack,
queue, tree & Graph etc.

Difference between Array and Linked List

32
3.3 REPRESENTATION OF LINKED LIST NODE

Let's see how each node of the linked list is represented. Each node
consists:
A data element
An address of another node

We wrap both the data item and the next node reference in a struct as:
struct node
{
int data;
struct node *next;
};
typedef struct node *node; //Define node as pointer of data type struct
node

The above definition is used to create every node in the list.

The data field stores the element and the next is a pointer to store the
address of the next node.

3.4 TYPES OF LINKED LIST

Singly Linked List

Singly linked lists contain nodes which have a data part as well as
an address part i.e. next, which points to the next node in the sequence of
nodes. Elements are navigated in forward direction.

The operations we can perform on singly linked lists

are insertion, deletion and traversal. The representation of the singly
linked list as shown below:

Representation of the node in a singly linked list-

struct node
{
int data;
struct node *next;
}

33
 Doubly Linked List
The node in a doubly-linked list has two address parts; one part
stores the address of the next while the other part of the node stores
the previous node's address. The initial node in the doubly linked list has
the NULL value in the address part, which provides the address of the
previous node. Elements can be navigated forward and backward. The
representation of the doubly linked list as shown below:

Representation of the node in a doubly linked list

struct node
{
int data;
struct node *next;
struct node *prev;
}

Circular Linked List A circular linked list is a sequence of

elements in which each node has a link to the next node, and the last node
is having a link to the first node. The representation of the circular linked
list will be similar to the singly linked list, as shown below:

Doubly Circular linked list

The doubly circular linked list in which the last node is attached to
the first node and thus creates a circle. It is a doubly linked list also
because each node holds the address of the previous node also. The main
difference between the doubly linked list and doubly circular linked list is
that the doubly circular linked list does not contain the NULL value in the
previous field of the node. As the doubly circular linked contains three
parts, i.e., two address parts and one data part so its representation is
similar to the doubly linked list.
34
Basic Operations on Linked List:
Following are the basic operations supported by a list.
Insertion .
Deletion
Display
Search

Memory Allocation and reallocation in Linked List:

Unlike an array, in linked list individual elements are stored
anywhere in memory. Each data element is called a node. A node contain
data and address (next) fields. Every nodes holds a pointer (next) to next
node in the list.

The memory is allocated for new node dynamically at runtime. A

linked list maintains the data elements in a logical order rather than in
physical order.

Dynamic memory management allows us to allocate additional

memory space or to release unwanted space during program execution.

The functions use for dynamic memory management are as follows-

malloc ()-Allocates as specified number of bytes in memory
calloc ()-Allocates space for an array of elements
free ()- Frees previously allocated space
realloc ()
()-Modifies the size of previously allocated space
struct node
{
int data;
struct node *next;
} N;
N *n;
n=(*N) malloc (sizeof (N))
free(n)
malloc ( ) is a system function which allocates a block of memory in the
"heap" and returns a pointer to the new block. The prototype of malloc()
and other heap functions are in stdlib.h. malloc() returns NULL if it cannot
fulfill the request.

It is defined by:
void *malloc (number_of_bytes)
void * is returned this pointer can be converted to any type.
35
 For example: char *cp;
cp = (char *) malloc (100);

Attempts to get 100 bytes and assigns the starting address to cp. We can
also use the sizeof() function to specify the number of bytes.
For example,
int *ip;
ip = (int *) malloc (100*sizeof(int));
free() is the opposite of malloc(), which de-allocates memory. The
argument to free() is a pointer to a block of memory in the heap a pointer
which was obtained by a malloc() function.

The syntax is: free (ptr);

The advantage of free() is simply memory management when we no

longer need a block.

3.5 SINGLY LINKED LIST

Singly linked list is a sequence of elements in which every element

has link to its next element in the sequence.

In any singly linked list, the individual element is called as

"Node". Every "Node" contains two fields, data field, and the next field.
The data field is used to store actual value of the node and next field is
used to store the address of next node in the sequence.

Implementation of Singly Linked List:

Before writing the code to build the above list, we need to create a
start node, used to create and access other nodes in the linked list. The
following structure definition will do

which will be
pointing to next node of the list? This is called as self-referential structure.

struct slink list

{ Node Structure: data next
int data;
structs link list* next; Empty List: NULL
};
Type def structs link list node; Start=NULL
node *start = NULL;

Figure 3.5.1. Structure definition, singly link node and empty list

There are various operations which can be performed on singly

linked list. A list of all such operations is given below.

36
 3.5.1. Creation of linked list.
3.5.2. Insertion of any element in the linked list.
3.5.3. Deletion any element from the linked list.
3.5.4. Traversing/Display of the linked list.

3.5.1. Creating a node for Singly Linked List:

Creating a singly linked list starts with creating a node. Sufficient
memory has to be allocated for creating a node. The information is stored
in the memory, allocated by using the malloc() function. The function
getnode(), is used for creating a node, after allocating memory for the
structure of type node, the information for the item (i.e., data) has to be
read from the user, set next field to NULL and finally returns the address
of the node.

node* getnode() newnode

{ 20 NULL
node* newnode;
newnode = (node *)malloc(sizeof(node)); 1000
printf("\n Enter data: ");
scanf("%d", &newnode -> data);
newnode -> next = NULL;
return newnode;
}
Figure 3.5.1.1.illustrates the creation of a node for singly linked list.

We can use the following algorithm steps to create a node of the

singly linked list...
Step 1: create the new node using getnode().
newnode = getnode();

Step 3 : If the list is empty, assign new node as start.

start = newnode;

Step 3 : If the list is not empty, follow the steps given below:

node) in the list by assigning the address of the first node.

of the new node.

37
 Fig.3.5.1.2.Pictorial Representation of Creation of singly linked list

The function createslist(), is

void createslist(int n)
{
int i;
node * newnode;
node *temp;
for( i = 0; i < n ; i++)
{
newnode = getnode();
if(start == NULL)
{
start = newnode;
}
else
38
 {
temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp -> next = newnode;
}
}
}

3.5.2.Insertion of any element in the linked list.

In a singly linked list, the insertion operation can be performed in
three ways. They are as follows...

Inserting At Beginning of the list

Inserting At End of the list
Inserting At Specific location in the list

Inserting At Beginning of the list

The following algorithm steps are to be followed to insert a new node at
the beginning of the list:

newnode = getnode();

start = newnode.

the list is not empty, follow the steps given below:

newnode -> next = start;
start = newnode;

Fig.3.5.2.1.Inserting node at beginning

39
 The function insert_at_beg(), is used for inserting a node at the
beginning
void insert_at_beg()
{
node *newnode;
newnode = getnode();
if(start == NULL)
{
start = newnode;
}
else
{
newnode -> next = start;
start = newnode;
}
}

Inserting At End of the list

The following algorithm steps are followed to insert a new node at
the end of the list:

the new node using getnode()

newnode = getnode();

start = newnode.

temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp -> next = newnode;

Fig.3.5.2.2.Inserting node at end

The function insert_at_end(), is used for inserting a node at the end.

void insert_at_end()
{
node *newnode, *temp;
newnode = getnode();
if(start == NULL)
{
40
 start = newnode;
}
else
{
temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp -> next = newnode;
}
}

Inserting a node at intermediate position:

The following algorithm steps are followed, to insert a new node in
an intermediate position in the list:

Step 1: Create the new node using getnode().

newnode = getnode();

Step 2: Ensure that the specified position is in between first node and last
node. If not, specified position is invalid. This is done by countnode()
function.

Step 3: Store the starting address (which is in start pointer) in temp and
temp1 pointers. Then traverse the temp pointer upto the specified position
followed by temp1pointer.

Step 4: After reaching the specified position, follow the steps given below:
temp -> next = newnode; newnode -> next = temp;

Fig.3.5.2.3.Inserting node at specified position

The function insert_at_mid(), is used for inserting a node in the

intermediate position.

41
void insert_at_mid()
{
node *newnode, *temp1, *temp;
intpos, nodectr, ctr = 1;
newnode = getnode();
printf("\n Enter the position: ");
scanf("%d", &pos);
nodectr = countnode(start);
if(pos> 1 &&pos<nodectr)
{
temp = temp1 = start;
while(ctr<pos)
{
temp = temp1;
temp1 = temp1 -> next;
ctr++;
}
temp -> next = newnode;
newnode -> next = temp1;
}
else
{
printf("position %d is not a middle position", pos);
}
}

3.5.3. Deletion of a node:

Another primitive operation that can be done in a singly linked list
is the deletion of a node. Memory is to be released for the node to be
deleted. A node can be deleted from the list from three different places
namely.

Deleting a node at the beginning:

Deleting a node from the beginning of the list is the simplest
operation of all. Since the first node of the list is to be deleted, therefore,
we just need to make the start, point to the next of the start. This will be
done by using the following statements.

Step 1: If list is empty then displa

Step 2: If the list is not empty, follow the steps given below:
temp = start;
start = start -> next;
free(temp);

42
 Fig. 3.5.3.1.Delete node from beginning position

The function delete_at_beg(), is used for deleting the first node in the list.
void delet_eat_beg()
{
node *temp;
if(start == NULL)
{
printf("\n No nodes are exist..");
return ;
}
else
{
temp = start;
start = temp -> next;
free(temp);
printf("\n Node deleted ");
}
}

Deleting a node at the end.

The following algorithm steps are followed to delete a node at the end of
the list:

temp = temp1 = start;

while(temp -> next != NULL)
{
temp1 = temp;
temp = temp -> next;
}
temp1 -> next = NULL;
free(temp);

43
 Fig. 3.5.3.2.Delete node from end position

The function delete_at_last(), is used for deleting the last node in the list.
void delete_at_last()
{
node *temp, *temp1;
if(start == NULL)
{
printf("\n Empty List..");
return ;
}
else
{
temp = temp1=start;
while(temp -> next != NULL)
{
temp1= temp;
temp = temp -> next;
}
temp1 -> next = NULL;
free(temp);
printf("\n Node deleted ");
}
}

Deleting a node at intermediate position.

The following algorithm steps are followed, to delete a node from
an intermediate position in the list (List must contain more than two node).

w the steps given below.

if(pos> 1 &&pos<nodectr)
{
temp = temp1 = start; ctr = 1;
while(ctr<pos)
{
temp1 = temp;
temp = temp -> next;
ctr++;
}

44
 temp1 -> next = temp -> next;
free(temp);
printf("\n node deleted..");
}

Fig. 3.5.3.3.Delete node from specified position

Thefunctiondelete_at_mid(),isusedfordeletingtheintermediatenodeinthelist.
void delete_at_mid()
{
intctr = 1, pos, nodectr;
node *temp, *temp1;
if(start == NULL)
{
printf("\n Empty List..");
return ;
}
else
{
printf("\n Enter position of node to delete: ");
scanf("%d", &pos);
nodectr = countnode(start);
if(pos>nodectr)
{
printf("\nThis node doesnot exist");
}
if(pos> 1 &&pos<nodectr)
{
temp = temp1 = start;
while(ctr<pos)
{
temp1 = temp;
temp = temp -> next;
ctr ++;
}
temp1 -> next = temp -> next;
free(temp);
printf("\n Node deleted..");
}
else
45
46
47
 return (count);
}
void createslist(int n)
{
int i;
node *newnode;
node *temp;
for(i = 0; i < n; i++)
{
newnode = getnode();
if(start == NULL)
{
start = newnode;
}
else
{
temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp -> next = newnode;
}
}
}
void traverse()
{
node *temp;
temp = start;
printf("\n The contents of List (Left to Right): \n");
if(start == NULL)
{
printf("\n Empty List");
return;
}
else
{
while(temp != NULL)
{
printf("%d-->", temp -> data);
temp = temp -> next;
}
}
printf(" NULL ");
}
void insert_at_beg()
{
node *newnode;
newnode = getnode();
if(start == NULL)
{
start = newnode;
48
 }
else
{
newnode -> next = start;
start = newnode;
}
}
void insert_at_end()
{
node *newnode, *temp;
newnode = getnode();
if(start == NULL)
{
start = newnode;
}
else
{
temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp -> next = newnode;
}
}
void insert_at_mid()
{
node *newnode, *temp1, *temp;
intpos, nodectr, ctr = 1;
newnode = getnode();
printf("\n Enter the position: ");
scanf("%d", &pos);
nodectr = countnode(start);
if(pos> 1 &&pos<nodectr)
{
temp = temp1 = start;
while(ctr<pos)
{
temp = temp1;
temp1 = temp1 -> next;
ctr++;
}
temp -> next = newnode;
newnode -> next = temp1;
}
else
{
printf("position %d is not a middle position", pos);
}
}

void delete_at_beg()
49
{
node *temp;
if(start == NULL)
{
printf("\n No nodes are exist..");
return ;
}
else
{
temp = start;
start = temp -> next;
free(temp);
printf("\n Node deleted ");
}
}
void delete_at_last()
{
node *temp, *temp1;
if(start == NULL)
{
printf("\n Empty List..");
return ;
}
else
{
temp = temp1=start;
while(temp -> next != NULL)
{
temp1= temp;
temp = temp -> next;
}
temp1 -> next = NULL;
free(temp);
printf("\n Node deleted ");
}
}
void delete_at_mid()
{
intctr = 1, pos, nodectr;
node *temp, *temp1;
if(start == NULL)
{
printf("\n Empty List..");
return ;
}
else
{
printf("\n Enter position of node to delete: ");
scanf("%d", &pos);
nodectr = countnode(start);
50
 if(pos>nodectr)
{
printf("\nThis node doesnot exist");
}
if(pos> 1 &&pos<nodectr)
{
temp = temp1 = start;
while(ctr<pos)
{
temp1 = temp;
temp = temp -> next;
ctr ++;
}
temp1 -> next = temp -> next;
free(temp);
printf("\n Node deleted..");
}
else
{
printf("\n Invalid position..");
getch();
}
}
}
void main(void)
{
intch, n;
clrscr();
while(1)
{
ch = menu();
switch(ch)
{
case 1:
if(start == NULL)
{
printf("\n Number of nodes you want to create: ");
scanf("%d", &n);
createslist(n);
printf("\n List created..");
}
else
printf("\n List is already created..");
break;
case 2:
insert_at_beg();
break;
case 3:
insert_at_end();
break;
51
 case 4:
insert_at_mid();
break;
case 5:
delete_at_beg();
break;
case 6:
delete_at_last();
break;
case 7:
delete_at_mid();
break;
case 8:
traverse();
break;
case 9:
printf("\n No of nodes : %d ", countnode(start));
break;
case 10 :
exit(0);
}
getch();
}
}

3.7 APPLICATIONS OF LINKED LIST

3.7.1 Searching a node in list:

Check whether the given key is present or not in the linked list.
Consider the Linked List : 10 20 30 40 NULL.
Input-20
Output=Search Found
Input-100
Output-Search Not Found

int search Node (node * l, int key)

{
node *temp = l;
while(temp != NULL)
{
if(temp->data == key)
return 1;
temp = temp->next;
}
return -1;
}
3.7.2 Merging of two linked List:
Given two linked list with Node values sorted in ascending order.

52
The linked List is-
1->2->3
4->5->6

Merging of two linked list is-

1->2->3->4->5->6

/* merges the two linked lists, restricting the common elements to occur
only once in the final list */
void merge ( struct node *l1, struct node *l2, struct node **newnode)
{
struct node *l3=NULL ;

/* if both lists are empty */

if ( l1 == NULL &&l2 == NULL )
return ;

/* traverse both linked lists till the end. If end of any one list is
reached loop is terminated */
while ( l1 != NULL &&l2 != NULL )
{
/* if node being added in the first node */
if ( *newnode == NULL )
{
*newnode = malloc(sizeof ( struct node ) ) ;
l3= *newnode ;
}
else
{
l3->next= malloc(sizeof ( struct node ) ) ;
l3 = l3 ->next ;
}
if ( l1 -> data <l2 -> data )
{
l3 -> data = l1 ->data ;
l1 = l1 ->next ;
}
else
{
if ( l2 -> data <l1 -> data )
{
l3 -> data = l2->data ;
l2 = l2 ->next ;
}
else
{
if ( l1 -> data == l2 -> data )
{
l3 -> data = l2 ->data ;
l1 = l1 ->next ;
53
 l2 = l2->next ;
}
}
}
}

/* if end of first list has not been reached */

while ( l1 != NULL )
{
l3 ->next = malloc(sizeof ( struct node ) ) ;
l3 = l3 ->next ;
l3 -> data = l1 ->data ;
l1 = l1 ->next ;
}

/* if end of second list has been reached */

while ( l2 != NULL )
{
l3 ->next = malloc(sizeof ( struct node ) ) ;
l3 = l3 ->next ;
l3 -> data = l2 ->data ;
l2 = l2 ->next ;
}
l3 ->next = NULL ;
}

3.7.3 Copy one singly linked list with other list:

void copy(node* l1, node*l2)

{
node* temp1, *temp2;
temp1=l1;
l2=(node*)malloc(sizeof(node));
temp2=l2;
while(temp1!=NULL)
{
temp2->data=temp1->data;
temp2->next=(node*)malloc(sizeof(node));
temp2=temp2->next;
temp1=temp1->next;
}
temp2=NULL;
\
while(l2->next!=NULL)
{
->data);
l2=l2->next;
}
}

54
3.7.4 Reversing the Linked List:

The linked list is-

10->20->34->NULL

The reverse Linked List is-

34->20->10-NULL

void reverse()
{
Node* temp1,*temp2,*temp3;
temp1=start;
If(temp1==NULL)
{
\
getch();
}
else
{
temp2=NULL;
while(temp1!=NULL)
{
temp3=temp2;
temp2=temp1;
temp1=temp1->next;
temp2=temp2->next;
}
start=temp2;
}
\
}

3.7.5 Splitting of two linked list:

List is :
1234567

Enter node after which u want to Split : 5

List is :
12345

List is :
67

void Split(struct node *start, int value, struct node **start1)

{
struct node *temp=start;
while(temp!=NULL)
{
if(temp->data==value)
55
 break;
temp=temp->link;
}
if(temp==NULL)
{
printf("\nValue does not exist\n");
return;
}
*start1=temp->link;
temp->link=NULL;
}/*End of Split()*/

3.8 SUMMARY

The malloc() is used for allocation of anode and free()is used for de-
allocation operation.
The singly linked list has only forward pointer and no backward link is
provided. Hence the traversing of the list is possible only in one
direction.
Backward traversing is not possible.
Insertion and deletion operations are less efficient because for
inserting the element at desired position the list needs to be traversed.
Similarly traversing of the list is required for locating the element
which needs to be deleted.

3.9 LIST OF REFERENCES

https://sites.google.com/site/datastructuresite/Home-Page/books
https://www.hackerearth.com/practice/data-structures/linked-list/singly-
linked-list/tutorial/

3.10 BIBLIOGRAPHY

1. Yashavant Kanetkar Data Structures Through C ,BPB Publications,

ISBN: 9788176567060,
2.
C++ , Wiley publication, ISBN-978-81-265-1260-7
3. D S Malik, Data Structures Using java, Thomson, India Edition 2006.
4. Sahni S, Data Structures, Algorithms and Applications in java,
McGraw-Hill, 2002.
5. SamantaD, Classic Data Structures, Prentice-Hall of India, 2001.
6. Tremblay P, and Sorenson P G, Introduction to Data Structures with
Applications, Tata McGraw-Hill,

56
7. Jean-Paul Tremblay and Paul G. Sorenson, An Introduction to Data
Structures with Applications, Tata McGraw Hill
8. Tanenbaum, Data Structures using C & C++, PHI
9. Robert L. Kruse, Data Structures and Program Design in C, PHI
10.

3.11 UNIT END EXERCISES

1. What is Linked List? State its types.

2. What are the advantages of a Linked List over an Array?
3. What is linked list? How it is different from array? Explain the
different types of linked list.
4. Explain the advantages and disadvantages of linked list.
5. Explain applications of Linked list.
6. Write the function to insert and delete a node in the beginning of a
Singly Linked List.
7. Write a C program to create and display Singly Linked List.
8. Write a C program to reverse a Singly Linked List.
9. Write a C program to merging of two Singly Linked List.
10. Write a C program to splitting Singly Linked List into two linked list.
11. Write a C program to search a node in Singly Linked List.

57
 4
LINKED LIST-II
Unit Structure :

4.0 Objectives
4.1 Introduction
4.2 Doubly Linked List
4.3 Applications of doubly linked list
4.4 Comparison between singly linked list and doubly linked list
4.5 Operations on doubly linked list
4.5.1 Creation of doubly linked list.
4.5.2 Insertion of any element in the linked list.
4.5.3 Deletion any element from the linked list.
4.5.4 Traversing/Display of the linked list.
4.6 Program on implementation of Doubly Linked List
4.7 Circular Linked List
4.8 Applications of circular linked list
4.9 Operations on doubly linked list
4.9.1 Creation of circular linked list.
4.9.2 Insertion of any element in the linked list.
4.9.3 Deletion any element from the linked list.
4.9.4 Traversing/Display of the linked list.
4.10 Program on implementation of Circular Singly Linked List
4.11 Representation of linked list using header node
4.12 Representation of Polynomial using Linked List
4.13 Representation of Sparse Matrix using Linked List
4.14 Summary
4.15 List of References
4.16 Bibliography
4.17 Unit End Exercises

4.0 OBJECTIVES

After going through this unit, you will be able to:

Implementation of doubly linked list with various operations
Implementation of circular linked list with various operations
Discuss applications of doubly and circular linked list
Explain the representation of polynomial and sparse matrix using
Linked List
58
4.1 INTRODUCTION

The linked list is a non primitive data structure which is free

from fixed memory size restriction. It is a linear collection of data element
and dynamic in nature. A linked list element cannot be stored in a
consecutive memory. It is static free and user can add any number of
elements when required. The linked list is a data structure and used to
create other data structures, like stacks, queues, etc. It allows the insertion
and deletion of nodes at any point in the list.

4.2 DOUBLY LINKED LIST

A double linked list is a two-way list in which all nodes will have
two links. This helps in accessing both successor node and predecessor
node from the given node position. It provides bi-directional traversing.
Each node contains three fields:
Prev link.
Data.
Next link.

The prev link points to the predecessor node and the next link
points to the successor node. The data field stores the required data. Many
applications require searching forward and backward through nodes of a
list. For example searching for a name in a telephone directory is popular
example.

Fig.4.1.Representation of doubly linked list

Implementation of Doubly Linked List:

Before writing the code to build the above list, we need to create a
start node, used to create and access other nodes in the linked list. The
following structure definition will do

pointing to next node of the list. This is called as self-referential structure.

59
structdlink list
{ Node
int data; Struct prev data next
structdlink list* next, * prev; ure:
};
typedefstructdlinklist node; Empty List: NULL
node *start = NULL;
Start=NULL
Figure 4.2 Structure definition, doubly link node and empty list

The prev part of the first node and the next part of the last node
will always contain null indicating end in each direction. There are various
operations which can be performed on doubly linked list.

4.3 APPLICATIONS OF DOUBLY LINKED LIST

1. Represents a deck of cards in a game.
2. Undo and redo operations in text editors
3. A music player which has next and previous button uses doubly linked
list
4. It is used to implement rewind and forward functions in the playlist.

4.4. COMPARISON BETWEEN SINGLY LINKED LIST

AND DOUBLY LINKED LIST

Singly Linked List Doubly Linked List

Singly Linked List is a collection Doubly Linked List is a collection
of nodes and each node is having of nodes and each node is having
one data field and next link field one data field and one previous link
Example: field and one next link field
Example:
Data Next field
Previous Data Next

The elements can be accessed using The elements can be accessed using
next link both previous link as well as next
link
It is not required extra field .Hence One filed is required to store
node takes less memory in SLL previous link .Hence node takes
more memory in DLL
Less efficient access to elements More efficient access to elements

60
 4.5 OPERATIONS ON DOUBLY LINKED LIST

A list of all such operations is given below.

4.5.1. Creation of doubly linked list.
4.5.2. Insertion of any element in the linked list.
4.5.3. Deletion any element from the linked list.
4.5.4. Traversing/Display of the linked list.

4.5.1. Creation of doubly linked list.

Creating a double linked list starts with creating a node. Sufficient
memory has to be allocated for creating a node. The information is stored
in the memory, allocated by using the malloc() function. The function
getnode(), is used for creating a node, after allocating memory for the
structur e of type node, the information for the item (i.e., data) has to be
read from the user and set prev field to NULL and next field also set to
NULL

node* getnode() newnode

{
node* newnode; NULL 20 NULL
newnode = (node *) malloc(sizeof(node));
printf("\n Enter data: "); 1000
scanf("%d", &newnode -> data);
newnode -> next = NULL;
newnode->prev=NULL;
return newnode;
}

number of nodes:
Get the new node using getnode().
newnode =getnode();
If the list is empty then start =temp= newnode
If the list is not empty, follow the steps given below:
temp-> n e x t =newnode;
newnode->prev=temp;

61
4.5.2. Insertion of any element in the linked list.
Inserting a node in the doubly linked list, there are 3 cases-
Inserting a node at beginning position
Inserting node at last position
Inserting node at intermediate position.
Inserting a node at the beginning:
The following algorithm steps are to be followed to insert a newnode
at the beginning of the list:
Cerate the newnode using getnode().
newnode=getnode();
If the list is empty then start=newnode.
If the list is not empty, follow the steps
given below:
newnode->next= start;
start->prev=newnode;
start=newnode;

62
 Fig.4.4.Shows inserting a node into the double linked list at the
beginning.
Inserting a node at the end:
The following algorithm steps are followed to insert a newnode at the
end of the list:

Create the new node using getnode()

newnode=getnode();
If the list is empty then start=newnode.
If the list is not empty follow the steps given below:temp=start;
while(temp -> next != NULL)
temp=temp->next;
temp -> next = newnode;
newnode->prev =temp;

Figure 4.5 shows inserting a node into the double linked list at the
end.
Inserting a node at an intermediate position:
The following algorithm steps are followed, to insert a new node in an
intermediate position in thelist:

Create the newnode using getnode().

newnode=getnode();

63
 Check that the specified position is in between first node and last node.
If not, specified position is invalid. This is done by countnode() function.
Store the starting address (which is in start pointer) in temp and prev
pointers. Then traverse the temp pointer upto the specified position
followed by prev pointer.
After reaching the specified position, follow the steps given below:
newnode -> next= temp -> next;
newnode->prev =temp;
temp -> next ->prev = newnode;
temp->next=newnode;

Figure 4.6 shows inserting a node into the double linked list at a
specified intermediate position other than beginning and end.

4.5.3. Deletion any element from the linked list

Deleting a node in the doubly linked list, there are 3 cases-
Delete a node from beginning position
Delete a node from last position
Delete a node from intermediate position.

Deleting a node at the beginning:

The following algorithm steps are followed, to delete a node at the
beginning of the list:

If the list is not empty, follow the steps given below:

temp=start;
start = start -> next;
start ->prev = NULL;
free(temp);

64
 Figure 4.7 Delete a node from beginning position

Deleting a node at the end:

The following steps are followed to delete a node at the end of the list:

If the list is not empty, follow the steps given below:

temp=start;
while(temp-> next !=NULL)
{
temp=temp->next;
}
temp ->prev -> next = NULL;free(temp);

Figure 4.8.showsdeleting a node at the end of a double linked list.

Deleting a node at Intermediate position:

The following steps are followed, to delete a node from an

intermediate position in the list(List must contain more than two nodes).

65
 specified position is in between first node and last node.If
not, specified position is invalid.

Then perform the following steps:

if(pos>1&&pos<nodectr)
{
temp = start;i= 1;
while(i<pos)
{
temp = temp ->next;i++;
}
temp -> next ->prev = temp ->prev;
temp ->prev -> next = temp -> next;
free(temp);
printf("\nnode deleted..");
}

Figure 4.9 shows deleting a node at a specified intermediate position

other than beginning and end from a double linked list.

4.6 PROGRAM ON IMPLEMENTATION OF DOUBLY

LINKED LIST

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct dlinklist
{
structdlinklist *prev;
int data;
structdlinklist *next;
};
66
typedef struct dlinklist node;
node *start = NULL;
node* getnode()
{
node * newnode;
newnode = (node *) malloc(sizeof(node));
printf("\n Enter data: ");
scanf("%d", &newnode -> data);
newnode ->prev = NULL;
newnode -> next = NULL;
returnnewnode;
}
int countnode(node *start)
{
if(start == NULL)
return 0;
else
return 1 + countnode(start -> next);
}
int menu()
{
intch;
clrscr();
printf("\n 1.Create");
printf("\n------------------------------");
printf("\n 2. Insert a node at beginning ");
printf("\n 3. Insert a node at end");
printf("\n 4. Insert a node at middle");
printf("\n------------------------------");
printf("\n 5. Delete a node from beginning");
printf("\n 6. Delete a node from Last");
printf("\n 7. Delete a node from Middle");
printf("\n------------------------------");
printf("\n 8. Traverse the list in forward direction ");
printf("\n 9. Traverse the list from backward direction ");
printf("\n------------------------------");
printf("\n 10.Count the Number of nodes in the list");
printf("\n 11.Exit");
printf("\n\n Enter your choice: ");
scanf("%d", &ch);
returnch;
}
void createdlist(int n)
{
int i;
node *newnode;
node *temp;
for(i = 0; i < n; i++)
{
newnode = getnode();
67
 if(start == NULL)
start = newnode;
else
{
temp = start;
while(temp -> next)
temp = temp -> next;
temp -> next = newnode;
newnode ->prev = temp;
}
}
}
void traverse_forward()
{
node *temp;
temp = start;
printf("\n The contents of List: ");
if(start == NULL )
printf("\n Empty List");
else
{
while(temp != NULL)
{
printf("\t %d ", temp -> data);
temp = temp -> next;
}
}
}
void traverse_backward()
{
node *temp;
temp = start;
printf("\n The contents of List: ");
if(start == NULL)
printf("\n Empty List");
else
{
while(temp -> next != NULL)
temp = temp -> next;
}
while(temp != NULL)
{
printf("\t%d", temp -> data);
temp = temp ->prev;
}
}
void dll_insert_beg()
{
node *newnode;
newnode = getnode();
68
 if(start == NULL)
start = newnode;
else
{
newnode -> next = start;
start ->prev = newnode;
start = newnode;
}
}
void dll_insert_end()
{
node *newnode, *temp;
newnode = getnode();
if(start == NULL)
start = newnode;
else
{
temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp -> next = newnode;
newnode ->prev = temp;
}
}
void dll_insert_mid()
{
node *newnode,*temp;
intpos, nodectr, ctr = 1;
newnode = getnode();
printf("\n Enter the position: ");
scanf("%d", &pos);
nodectr = countnode(start);
if(pos - nodectr>= 2)
{
printf("\n Position is out of range..");
return;
}
if(pos> 1 &&pos<nodectr)
{
temp = start;
while(ctr<pos - 1)
{
temp = temp -> next;
ctr++;
}
newnode ->prev = temp;
newnode -> next = temp -> next;
temp -> next ->prev = newnode;
temp -> next = newnode;
}
69
else
printf("position %d of list is not a middle position ", pos);
}
void dll_delete_beg()
{
node *temp;
if(start == NULL)
{
printf("\n Empty list");
getch();
return ;
}
else
{
temp = start;
start = start -> next;
start ->prev = NULL;
free(temp);
}
}
void dll_delete_last()
{
node *temp;
if(start == NULL)
{
printf("\n Empty list");
getch();
return ;
}
else
{
temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp ->prev -> next = NULL;
free(temp);
temp = NULL;
}
}
void dll_delete_mid()
{
int i = 0, pos, nodectr;
node *temp;
if(start == NULL)
{
printf("\n Empty List");
getch();
return;
}
else
70
 {
printf("\n Enter the position of the node to delete: ");
scanf("%d", &pos);
nodectr = countnode(start);
if(pos>nodectr)
{
printf("\nthis node does not exist");
getch();
return;
}
if(pos> 1 &&pos<nodectr)
{
temp = start;
i= 1;
while(i <pos)
{
temp = temp -> next;
i++;
}
temp -> next ->prev = temp ->prev;
temp ->prev -> next = temp -> next;
free(temp);
printf("\n node deleted..");
}
else
{
printf("\n It is not a middle position..");
getch();
}
}
}
void main(void)
{
intch, n;
clrscr();
while(1)
{
ch = menu();
switch(ch)
{
case 1 :
printf("\n Enter Number of nodes to create: ");
scanf("%d", &n);
createdlist(n);
break;
case 2 :
dll_insert_beg();
break;
case 3 :
dll_insert_end();
71
 break;
case 4 :
dll_insert_mid();
break;
case 5 :
dll_delete_beg();
break;
case 6 :
dll_delete_last();
break;
case 7 :
dll_delete_mid();
break;
case 8 :
traverse_ forward ();
break;
case 9 :
traverse_backward();
break;
case 10 :
printf("\n Number of nodes: %d", countnode(start));
break;
case 11:

exit(0);
}
getch();
}
}

4.7. CIRCULAR SINGLY LINKED LIST

The linked list where the last node points the start node is called
circular linked list. A circular linked list has no beginning and no end. It is
necessary to establish a special pointer called start pointer always pointing
to the first node of the list. Hence we can move from last node to the start
node of the list very efficiently. Hence accessing of any node is much
faster than singly linked list. In circular linked list no null pointers are
used, hence all pointers contain valid address.

A circular singly linked list is shown in figure 3.6.1.

Figure 4.7.1.Circular Singly Linked List

72
Advantages of circular linked list:
Accessibility of a number node in the list
No null link problem
Merging and splitting operations implemented easily
Saves time when you want to go from last node to first node

Disadvantages of circular linked list

The list will go infinite lop, if proper case is not taken.
It is not easy to reverse the list elements.

4.8 APPLICATIONS IN CIRCULAR LINKED LIST

1. It is used in operating system. When multiples applications are running

in PC operating system to put the running applications on a list and
then to cycle through them ,giving each of them a slice of time to
execute, and then making them wait while the CPU is given to another
applications.
2. To repeat songs in the music player
3. Escalator which will run circularly uses the circular linked list

4.9 OPERATIONS IN A CIRCULAR SINGLE LINKED

LIST ARE

4.9.1. Creation of node in circular linked list

4.9.2. Insertion a node in circular linked list
4.9.3. Delete a node in circular linked list
4.9.4. Displaying/Traversing a node in circular linked list

4.9.1.Creating

nodes:

newnode = getnode();

start = newnode;

temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp -> next = newnode;

-> next = start;

73
 Fig.4.10. Creation of circular linked list

4.9.2. Insertion a node in circular linked list

Inserting a node in the doubly linked list, there are 3 cases-
Inserting a node at beginning position
Inserting node at last position
Inserting node at intermediate position.

Inserting a node at the beginning:

The following algorithm steps are to be followed to insert a new node at
the beginning of the circular list:

newnode = getnode();

start = newnode;
newnode -> next = start;

temp = start;
while(temp -> next != start)
temp= temp -> next;
newnode -> next = start;
start = newnode;
temp -> next = start;

74
 4.11. shows inserting a node into the circular single linked list at the
beginning.

Inserting a node at the end:

The following algorithm steps are followed to insert a new node at the end
of the list:

newnode = getnode();

start = newnode;
newnode -> next = start;

temp = start;
while(temp -> next != start)
temp = temp -> next;
temp -> next = newnode;
newnode -> next = start;
The function cll_insert_end(), is used for inserting a node at the end.

Figure 4.12 shows inserting a node into the circular single linked list at the
end.

Figure 4.12 Inserting a node at the end

75
 Inserting a node at intermediate position:
The following algorithm steps are followed, to insert a new node in an
intermediate position in the list:

Step 1: Create the new node using getnode().

newnode = getnode();

Step 2: Ensure that the specified position is in between first node and last
node. If not, specified position is invalid. This is done by countnode()
function.

Step 3: Store the starting address (which is in start pointer) in temp and
prev pointers. Then traverse the temp pointer upto the specified position
followed by prev pointer.

Step 4: After reaching the specified position, follow the steps given below:
temp1 -> next = newnode;
newnode -> next = temp;

position be 3.

Figure 4.13 shows inserting a node into the double linked list at a
specified intermediate position other than beginning and end.

4.9.3 Deletion any element from the linked list

Deleting a node in the doubly linked list, there are 3 cases-
Delete a node from beginning position
Delete a node from last position
Delete a node from intermediate position.

Deleting a node at the beginning:

The following algorithm steps are followed, to delete a node at the
beginning of the list:

temp1 = temp = start;

while(temp1 -> next != start)
temp1= temp1 -> next;
start = start -> next;
temp1 -> next = start;
start = NULL.
76
The function cll_delete_beg(), is used for deleting the first node in the list

Figure 4.14 Deleting a node at beginning.

Deleting a node at the end:
The following algorithm steps are followed to delete a node at the
end of the list:

temp = start;
temp1 = start;
while(temp -> next != start)
{
temp1=temp;
temp = temp -> next;
}
temp1 -> next = start;
start = NULL.

The function cll_delete_last(), is used for deleting the last node in the list.

Figure 4.15 Deleting a node at the end

Deleting a node at intermediate position.

The following algorithm steps are followed, to delete a node from
an intermediate position in the list (List must contain more than two node).

he steps given below.

77
 if(pos> 1 &&pos<nodectr)
{
temp = temp1 = start; ctr = 1;
while(ctr<pos)
{
temp1 = temp;
temp = temp -> next;
ctr++;
}
temp1 -> next = temp -> next;
free(temp);
printf("\n node deleted..");
}

Figure 4.16 .Deleting a node in intermediate position

4.9.4 Traversing a circular single linked list from left to right:

The following algorithm steps are followed, to traverse a list from
left to right:

the list is not empty, follow the steps given below:

temp = start;
do
{
printf("%d", temp -> data);
temp = temp -> next;
} while(temp != start);

4.10 PROGRAM ON IMPLEMENTATION OF

CIRCULAR SINGLE LINKED LIST

# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
struct cslinklist
{
78
 int data;
struct cslinklist *next;
};
typedef struct cslinklist node;
node *start = NULL;
int nodectr;
node* getnode()
{
node * newnode;
newnode = (node *) malloc(sizeof(node));
printf("\n Enter data: ");
scanf("%d", &newnode -> data);
newnode -> next = NULL;
returnnewnode;
}
int menu()
{
intch;
clrscr();
printf("\n 1. Create a list ");
printf("\n\n--------------------------");
printf("\n 2. Insert a node at beginning ");
printf("\n 3. Insert a node at end");
printf("\n 4. Insert a node at middle");
printf("\n\n--------------------------");
printf("\n 5. Delete a node from beginning");
printf("\n 6. Delete a node from Last");
printf("\n 7. Delete a node from Middle");
printf("\n\n--------------------------");
printf("\n 8. Display the list");
printf("\n 9. Exit");
printf("\n\n--------------------------");
printf("\n Enter your choice: ");
scanf("%d", &ch);
returnch;
}
void createlist(int n)
{
int i;
node *newnode,*temp;
nodectr = n;
for(i = 0; i < n ; i++)
{
newnode = getnode();
if(start == NULL)
{
start = newnode;
}
else
{
79
 temp = start;
while(temp -> next != NULL)
temp = temp -> next;
temp -> next = newnode;
}
}
newnode ->next = start; /* last node is pointing to starting node */
}
void display()
{
node *temp;
temp = start;
printf("\n The contents of List (Left to Right): ");
if(start == NULL )
printf("\n Empty List");
else
{
do
{
printf("\t %d ", temp -> data);
temp = temp -> next;
} while(temp != start);
printf(" NULL ");
}
}
void cll_insert_beg()
{
node *newnode, *temp;
newnode = getnode();
if(start == NULL)
{
start = newnode;
newnode -> next = start;
}
else
{
temp = start;
while(temp -> next != start)
temp= temp -> next;
newnode -> next = start;
start = newnode;
temp -> next = start;
}
printf("\n Node inserted at beginning..");
nodectr++;
}
void cll_insert_end()
{
node *newnode, *temp;
newnode = getnode();
80
 if(start == NULL )
{
start = newnode;
newnode -> next = start;
}
else
{
temp = start;
while(temp -> next != start)
temp = temp -> next;
temp -> next = newnode;
newnode -> next = start;
}
printf("\n Node inserted at end..");
nodectr++;
}
void cll_insert_mid()
{
node *newnode, *temp, *prev;
int i, pos ;
newnode = getnode();
printf("\n Enter the position: ");
scanf("%d", &pos);
if(pos> 1 &&pos<nodectr)
{
temp = start;
temp1= temp;
i= 1;
while(i <pos)
{
temp1 = temp;
temp = temp -> next;
i++;
}
temp1 -> next = newnode;
newnode -> next = temp;
nodectr++;
printf("\n Node inserted at middle..");
}
else
{
printf("position %d of list is not a middle position ", pos);
}
}
void cll_delete_beg()
{
node *temp, *last;
if(start == NULL)
{
printf("\n No nodes exist..");
81
 getch();
return ;
}
else
{
last = temp = start;
while(last -> next != start)
last= last -> next;
start = start -> next;
last -> next = start;
free(temp);
nodectr--;
printf("\n Node deleted..");
if(nodectr == 0)
start = NULL;
}
}
void cll_delete_last()
{
node *temp,*prev;
if(start == NULL)
{
printf("\n No nodes exist..");
getch();
return ;
}
else
{
temp = start;
temp1 = start;
while(temp -> next != start)
{
temp1= temp;
temp = temp -> next;
}
temp1 -> next = start;
free(temp);
nodectr--;
if(nodectr == 0)
start = NULL;
printf("\n Node deleted..");
}
}
void cll_delete_mid()
{
int i = 0, pos;
node *temp, *prev;
if(start == NULL)
{
printf("\n No nodes exist..");
82
 getch();
return ;
}
else
{
printf("\n Which node to delete: ");
scanf("%d", &pos);
if(pos>nodectr)
{
printf("\nThis node does not exist");
getch();
return;
}
if(pos> 1 &&pos<nodectr)
{
temp=start;
temp1 = start;
i= 0;
while(i <pos - 1)
{
temp1 = temp;
temp = temp -> next ;
i++;
}
temp1 -> next = temp -> next;
free(temp);
nodectr--;
printf("\n Node Deleted..");
}
else
{
printf("\n It is not a middle position..");
getch();
}
}
}
void main(void)
{
int result;
intch, n;
clrscr();
while(1)
{
ch = menu();
switch(ch)
{
case 1 :
if(start == NULL)
{
printf("\n Enter Number of nodes to create: ");
83
 scanf("%d", &n);
createlist(n);
printf("\nList created..");
}
else
printf("\n List is already Exist..");
break;
case 2 :
cll_insert_beg();
break;
case 3 :
cll_insert_end();
break;
case 4 :
cll_insert_mid();
break;
case 5 :
cll_delete_beg();
break;
case 6 :
cll_delete_last();
break;
case 7 :
cll_delete_mid();
break;
case 8 :
display();
break;
case 9 :
exit(0);
}

4.11 REPRESENTATION OF LINKED LIST USING

HEADER NODE

A header linked list is a type of linked list which always contains a

special node called the header node at the very beginning of the linked list.
It is an extra node kept at the front of a list.

Such a node does not represent an item in the linked list. The
information part of this node can be used to store any global information
about the whole linked list. A header node is a special dummy node found
at the front of the list. The use of header node is an alternative to remove
the first node in a list.

84
For example, the picture below

Fig.4.17 Representation of Polynomial using Linked List

Advantages of header node-

In header node, you can maintain count variable which gives number
of nodes in the list. You can update header node count member
whenever you add /delete any node. It will help in getting list count
without traversing list.
In addition to address of first node you can also store the address of
last node. So that if you want to insert node at the rear end you don't
have to iterate from the beginning of the list. Also in the case of
DLL(Doubly Linked List) if you want to traverse from rear end it
helps.
We can also use it to store the pointer to the current node in the linked
list which eliminates the need of an external pointer during the
traversal of the linked list.
While inserting a new node in the linked list we don't need to check
whether start node is null or not because the header node will always
exist and we can insert a new node just after that.

4.12 REPRESENTATION OF POLYNOMIAL USING

LINKED LIST

A polynomial is composed of different terms where each of them

holds a coefficient and an exponent.

An essential characteristic of the polynomial is that each term in

the polynomial expression consists of two parts: one is the coefficient and
other is the exponent 13x2 + 36x, here 13 and 36 are coefficients and 2, 1
is its exponential value.

The sign of each coefficient and exponent is stored within the

coefficient and the exponent itself

Additional terms having equal exponent is possible one.

The storage allocation for each term in the polynomial must be
done in ascending and descending order of their exponent. The linked list
85
can be used to represent a polynomial of any degree. Simply the
information field is changed according to the number of variables used in
the polynomial. If a single variable is used in the polynomial the
information field of the node contains two parts: one for coefficient of
variable and the other for exponent of variable.

Let us consider an example to represent a polynomial using linked

list as follows:
Polynomial: 3x3-4x2+2x-9
Polynomial can be represented in the following ways.

Fig.4.18 Representation of Polynomial using Linked List

Representation of a polynomial using the linked list is beneficial

when the operations on the polynomial like addition and subtractions are
performed. The resulting polynomial can also be traversed very easily to
display the polynomial.

The linked list is used for polynomial arithmetic because it can

have separate coefficient and exponent fields for representing each term of
polynomial. Hence there is no limit for exponent. We can have any
number as an exponent. The arithmetic operation on any polynomial of
arbitrary length is possible using linked list.

Program for polynomial creation with help of linked list:

#include <conio.h>
#include <stdio.h>
#include <malloc.h>
struct link
{
Int coef; int expo;
struct link *next;
};
typedef struct link node;
node * getnode()
{
node *newnode;
86
 newnode =(node *) malloc( sizeof(node) );
printf("\n Enter Coefficient : ");
fflush(stdin);
scanf("%f",&newnode ->coef);
printf("\n Enter Exponent : ");
fflush(stdin);
scanf("%d",&newnode ->expo);
newnode ->next = NULL;
returnnewnode;
}
node * create_poly (node *p )
{
charch;
node *temp,*newnode;
while( 1 )
{
printf ("\n Do U Want polynomial node (y/n): ");
ch = getche();
if(ch == 'n')
break;
newnode = getnode();
if( p == NULL )
p= newnode;
else
{
temp = p;
while(temp->next != NULL )
temp = temp->next;
temp->next = newnode;
}
}
return p;
}
void display (node *p)
{
node *t = p;
while (t != NULL)
{
printf("+ %.2d", t ->coef);
printf("X^ %d", t -> expo);
t=t -> next;
}
}
void main()
{
node *poly1 = NULL ,*poly2 = NULL,*poly3=NULL;
clrscr();
printf("\nEnter First Polynomial..(in ascending-order of exponent)");
poly1 = create_poly (poly1);

87
 printf("\nEnter Second Polynomial..(in ascending-order of
exponent)");
poly2 = create_poly (poly2);
clrscr();
printf("\n Enter Polynomial 1: ");
display (poly1);
printf("\n Enter Polynomial 2: ");
display (poly2);
getch();
}

4.13 REPRESENTATION OF SPARSE ARRAY USING

LINKED LIST

A matrix can be defined as a two-dimensional array having 'm'

columns and 'n' rows representing m*n matrix. Sparse matrices are those
matrices that have the maximum elements equal to zero. In other words,
the sparse matrix can be defined as the matrix that has a greater number of
zero elements than the non-zero elements.

Advantages of sparse matrix instead of over a simple matrix

o Storage: As we know, a sparse matrix that contains lesser non-zero
elements than zero so less memory can be used to store elements. It
evaluates only the non-zero elements.

o Computing time: In the case of searching n sparse matrix, we need to

traverse only the non-zero elements rather than traversing all the sparse
matrix elements. It saves computing time by logically designing a data
structure traversing non-zero elements.

Representing a sparse matrix by a 2D array leads to the wastage of

lots of memory. The zeroes in the matrix are of no use to store zeroes with
non-zero elements. To avoid such wastage, we can store only non-zero
elements. If we store only non-zero elements, it reduces the traversal time
and the storage space.

Representation of Sparse Matrix

The non-zero elements can be stored with triples, i.e., rows,
columns, and value. The sparse matrix can be represented in the following
ways:
Array representation
Linked list representation
Array Representation

The 2 d array can be used to represent a sparse matrix in which

there are three rows named as:

1. Row: It is an index of a row where a non-zero element is located.

88
2. Column: It is an index of the column where a non-zero element is
located.
3. Value: The value of the non-zero element is located at the index (row,
column).

Let us consider 4X4 matrix elements are-

1 0 0 -4
0 6 0 0
0 0 7 0
0 5 0 0

As we can observe above, that sparse matrix is represented using

triplets, i.e., row, column, and value. In the above sparse matrix, there are
11 zero elements and 5 non-zero elements. If the size of the sparse matrix
is increased, then the wastage of memory space will also be increased. The
above sparse matrix can be represented in the tabular form shown as
below:

Row Col Value

4 4 5
0 0 1
0 3 -4
1 1 6
2 2 7
3 1 5
In the above table structure, the first column is representing the
row number, the second column is representing the column number and
third column represents the non-zero value at index(row, column). The
size of the table depends upon the number of non-zero elements in the
sparse matrix.

Linked List Representation

In linked list representation, linked list data structure is used to
represent a sparse matrix. In linked list representation, each node consists
of four fields whereas, in array representation, there are three fields, i.e.,
row, column, and value. The following are the fields in the linked list:
Row: It is an index of row where a non-zero element is located.
Column: It is an index of column where a non-zero element is located.
Value: It is the value of the non-zero element which is located at the
index (row, column).
Next node: It stores the address of the next node.

89
 Fig.4.19. Representation of Sparse Matrix using Linked List

4.14 SUMMARY

The doubly linked list has two pointer fields. One field is previous link
field and another is next link field. By using these two pointers we can
access any node efficiently whereas in singly linked list only one
pointer field which stores forward pointer.
In circular list the next pointer of last node points to start node,
whereas in doubly linked list each node has two pointers. The main
advantage of circular list over doubly linked list is that with the help of
single pointer field we can access start node quickly. So amount of
memory get saved.
The header node is the first node of linked list. This node is useful for
getting starting address of linked list.
Polynomials and Sparse Matrix are two important applications of
arrays and linked lists.

4.15 LIST OF REFERENCES

1. https://sites.google.com/site/datastructuresite/Home-Page/books
2. https://www.hackerearth.com/practice/data-structures/linked-
list/singly-linked-list/tutorial/
3. https://dscet.ac.in/questionbank/cse/third-sem/CS8391-DATA-
STRUCTURES.pdf

4.16 Bibliography

1. YashavantKanetkar Data Structures Through C ,BPB Publications,

ISBN: 9788176567060,
2.
C++ , Wiley publication, ISBN-978-81-265-1260-7
3. D S Malik, Data Structures Using java, Thomson, India Edition 2006.
4. Sahni S, Data Structures, Algorithms and Applications in java,
McGraw-Hill, 2002.
5. SamantaD, Classic Data Structures, Prentice-Hall of India, 2001.
90
6. Tremblay P, and Sorenson P G, Introduction to Data Structures with
Applications, Tata McGraw-Hill,
7. Jean-Paul Tremblay and Paul G. Sorenson, An Introduction to Data
Structures with Applications, Tata McGraw Hill
8. Tanenbaum, Data Structures using C & C++, PHI
9. Robert L. Kruse, Data Structures and Program Design in C, PHI
10.

4.17UNIT END EXERCISES

1.
at the end of a Doubly Linked List.
2. What is difference between the singly and doubly link list. Mention
the significance of a circular linked list.
3. What is doubly linked list? What advantages does a doubly linked
list have over linear linked lists?
4. How a linked list can be used to represent a polynomial of type:-
9x2y2-8xy2+10xy+9y2
5. Describe the applications of linked list on polynomial Expressions.
6. Describe the operations are performed on Circular Linked List.
7. Explain the operations are performed on the singly linked list.
8. What is header node and what is the use of it?
9. Write a C function to find product of all elements of Linked List?
10. What are advantages of doubly linked list over singly linked list?
11. Why the linked list is used for representation of polynomial?
12. What are advantages of circular linked list over doubly linked list?
13. Write program to implement circular linked list.
14. Write program to implement doubly linked list.
15. What is Circular Linked List? State the advantages and
disadvantages of Circular Link List Over Doubly Linked List and
Singly Linked List

91
 Unit III

5
STACK
Unit Structure

5.0 Objectives
5.1 Introduction
5.2 Operations on the Stack Memory Representation of Stack
5.3 Array Representation of Stack
5.4 Applications of Stack
5.4.1 Evaluation of Arithmetic Expression
5.4.2 Matching Parenthesis
5.4.3 Infix and postfix operations
5.4.4 Memory management
5.4.5 Recursion
5.5 Summary
5.6 References
5.7 Unit End Exercise

5.0 OBJECTIVES

After reading through this chapter, you will be able to –

To understand the basic concepts about stacks.
To impart the operations on the stack memory representation.
To understand the array representation of stack.
To understand the applications of stack.
To understand the evaluation of arithmetic operations on stack.
To understand the matching parenthesis.
To understand the infix and postfix operations on stack.

5.1 INTRODUCTION

Stack is a simple data structure that allows adding and removing

elements in a particular order.
Every time an element is added, it goes on the top of the stack and the
only element that can be removed is the element that is at the top of
the stack, just like a pile of objects.

92
 Stack is an ordered list of similar data type.
Stack is a LIFO (Last in First out) structure or we can say FILO (First
in Last out).
push() function is used to insert new elements into the Stack
and pop() function is used to remove an element from the stack. Both
insertion and removal are allowed at only one end of Stack called Top.
Stack is said to be in Overflow state when it is completely full and is
said to be in Underflow state if it is completely empty.

5.2 OPERATIONS ON THE STACK MEMORY

REPRESENTATION OF STACK

Stack can be easily implemented using an Array or a Linked List.

Arrays are quick, but are limited in size and Linked List requires overhead
to allocate, link, unlink, and deallocate, but is not limited in size. Here we
will implement Stack using array.

Basic Operations:
93
 Stack operations may involve initializing the stack, using it and then
de-initializing it. Apart from these basic stuffs, a stack is used for the
following two primary operations
push() Pushing (storing) an element on the stack.
pop() Removing (accessing) an element from the stack.
When data is Pushed onto stack. To use a stack efficiently, we need to
check the status of stack as well.
For the same purpose, the following functionality is added to stacks
peek() get the top data element of the stack, without removing it.
isFull() check if stack is full.
isEmpty() check if stack is empty.
At all times, we maintain a pointer to the last Pushed data on the stack.
As this pointer always represents the top of the stack, hence
named top.
The top pointer provides top value of the stack without actually
removing it.

Algorithm for PUSH operation:

1. Check if the stack is full or not.
2. If the stack is full, then print error of overflow and exit the program.
3. If the stack is not full, then increment the top and add the element.

Algorithm for POP operation:

1. Check if the stack is empty or not.
2. If the stack is empty, then print error of underflow and exit the program.
3. If the stack is not empty, then print the element at the top and decrement
the top.

Below we have a simple C++ program implementing stack data

structure while following the object-oriented programming concepts.
# include<iostream>
using namespace std;
class Stack
{
int top;
public:
int a[10]; //Maximum size of Stack
Stack()
{
top = -1;
}
// declaring all the function
void push(int x);
int pop();
void isEmpty();
};
94
// function to insert data into stack
void Stack::push(int x)
{
if(top >= 10)
{
cout << "Stack Overflow \n";
}
else
{
a[++top] = x;
cout << "Element Inserted \n";
}
}
// function to remove data from the top of the stack
int Stack::pop()
{
if(top < 0)
{
cout << "Stack Underflow \n";
return 0;
}
else
{
int d = a[top--];
return d;
}
}

// function to check if stack is empty

void Stack::isEmpty()
{
if(top < 0)
{
cout << "Stack is empty \n";
}
else
{
cout << "Stack is not empty \n";
}
}

// main function
int main() {
Stack s1;
s1.push(10);
s1.push(100);
}

95
 Position of Top Status of Stack
-1 Stack is Empty
0 Only one element in Stack
N-1 Stack is Full
N Overflow state of Stack

5.3 ARRAY REPRESENTATION OF STACK

A stack is a data structure that can be represented as an array. Let us

learn more about Array representation of a stack.
An array is used to store an ordered list of elements. Using an array for
representation of stack is one of the easy techniques to manage the
data.
There is a major difference between an array and a stack.
Size of an array is fixed.
While, in a stack, there is no fixed size since the size of stack
changed with the number of elements inserted or deleted to and
from it.
The difference, an array can be used to represent a stack by taking an
array of maximum size big enough to manage a stack.

Example:
We are given a stack of elements: 12, 08, 21, 33, 18, 40.

96
Step1:
Push (40)
Top = 40
Element is inserted at a[5]

Step2:
Push (18)
Top = 18
Element is inserted at a[4]

Step3:
Push (33)
Top = 33
Element is inserted at a[3]

Step 4:
Push (21)
Top = 21
Element is inserted at a[2]

Step 5:
Push (8)
Top = 8
Element is inserted at a[1]

Step 6:
Push (12)
Top = 12
Element is inserted at a[0]

97
Step 7:
Top = -1
End of array

Code of stack (using structure)

// Program for Implementation of stack (array) using structure
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

// A structure to represent a stack

struct Stack {
int top;
int maxSize;
int* array;
};
struct Stack* create(int max)
{
struct Stack* stack = (struct Stack*) malloc (sizeof (struct Stack));
stack->maxSize = max;
stack->top = -1;
stack->array = (int*) malloc(stack->maxSize * sizeof(int));
//here above memory for array is being created
// size would be 10*4 = 40
return stack;
}
// Checking with this function is stack is full or not
// Will return true is stack is full else false
//Stack is full when top is equal to the last index
int isFull(struct Stack* stack)
{
if(stack->top == stack->maxSize - 1){
printf ("Will not be able to push maxSize reached\n");
}
// Since array starts from 0, and maxSize starts from 1
return stack->top == stack->maxSize - 1;
}
// By definition the Stack is empty when top is equal to -1
// Will return true if top is -1
int isEmpty (struct Stack* stack)
{
98
 return stack->top == -1;
}

// Push function here, inserts value in stack and increments stack top by 1
void push (struct Stack* stack, int item)
{
if (isFull(stack))
return;
stack->array[++stack->top] = item;
printf("We have pushed %d to stack\n", item);
}

// Function to remove an item from stack. It decreases top by 1

int pop(struct Stack* stack)
{
if (isEmpty(stack))
return INT_MIN;
return stack->array[stack->top--];
}

// Function to return the top from stack without removing it

int peek(struct Stack* stack)
{
if (isEmpty(stack))
return INT_MIN;
return stack->array[stack->top];
}

int main ()
{
struct Stack* stack = create (10);

push(stack, 5);
push(stack, 10);
push(stack, 15);

int flag=1;
while(flag)
{
if(! isEmpty(stack))
printf("We have popped %d from stack\n", pop(stack));
else
printf("Can't Pop stack must be empty\n");
printf("Do you want to Pop again? Yes: 1 No: 0\n");
scanf("%d",&flag);
}
return 0;
}
Output:
We have pushed 5 to stack
99
We have pushed 10 to stack
We have pushed 15 to stack
We have popped 15 from the stack
Do you want to Pop again? Yes: 1 No: 0
0

5.4 APPLICATIONS OF STACK

In a stack, only limited operations are performed because it is restricted

data structure. The elements are deleted from the stack in the reverse
order.
Following are the applications of stack:
1. Evaluation of Arithmetic Expression
2. Matching Parenthesis
3. Expression Conversion
i. Infix to Postfix
ii. Postfix to Infix
iii. Prefix to Infix
4. Memory Management

5.4.1Evaluation of Arithmetic Expression:

Stack data structure is used for evaluating the given expression. For
example, consider the following expression
5 * (6 + 2) - 12 / 4
Since parenthesis has the highest precedence among the arithmetic
operators,
(6 +2) = 8 will be evaluated first. Now, the expression becomes
5 * 8 - 12 / 4
* and / have equal precedence and their associativity is from left-to-
right. So, start evaluating the expression from left-to-right.
5 * 8 = 40 and 12 / 4 = 3
Now, the expression becomes
40 - 3
And the value returned after the subtraction operation is 37.

5.4.2 Matching Parenthesis:

One of the most important applications of stacks is to check if the
parentheses are balanced in a given expression. The compiler generates an
error if the parentheses are not matched.
Here are some of the balanced and unbalanced expressions:

100
 Consider the above-mentioned unbalanced expressions:
The first expression (a + b is unbalanced as there is no closing
parenthesis given.
The second expression [ (c - d * e] is unbalanced as the closed
round parenthesis is not given.
The third expression { [( ] ) } is unbalanced as the nesting of
square parenthesis and the round parenthesis are incorrect.
Steps to find whether a given expression is balanced or unbalanced
Input the expression and put it in a character stack.
Scan the characters from the expression one by one.
If the scanned character is a starting bracket (‘(‘or ‘{‘or ‘[ ‘), then
push it to the stack.
If the scanned character is a closing bracket (‘)’ or ‘}’ or ‘]’), then
pop from the stack and if the popped character is the equivalent
starting bracket, then proceed. Else, the expression is unbalanced.
After scanning all the characters from the expression, if there is
any parenthesis found in the stack or if the stack is not empty, then
the expression is unbalanced.

5.4.3 Expression Conversion:

There are three popular methods used for representation of an
expression
Infix A+B Operator between operands.
Prefix + AB Operator before operands.
Postfix AB + Operator after operands.

i. Conversion of Infix to Postfix:

Step 1: Consider the next element in the input.
Step 2: If it is operand, display it.
Step 3: If it is opening parenthesis, insert it on stack.
Step 4: If it is an operator, then
If stack is empty, insert operator on stack.
If the top of stack is opening parenthesis, insert the operator on
stack
If it has higher priority than the top of stack, insert the operator on
stack.
Else, delete the operator from the stack and display it, repeat Step
4.
Step 5: If it is a closing parenthesis, delete the operator from stack and
display them until an opening parenthesis is encountered. Delete and
discard the opening parenthesis.

101
Step 6: If there is more input, go to Step 1.
Step 7: If there is no more input, delete the remaining operators to output.

Example: Suppose we are converting 3*3/ (4-1) +6*2 expression into

postfix form.

Expression Stack Output

3 Empty 3
* * 3
3 * 33
/ / 33*
( /( 33*
4 /( 33*4
- /(- 33*4
1 /(- 33*41
) - 33*41-
+ + 33*41-/
6 + 33*41-/6
* +* 33*41-/62
2 +* 33*41-/62
Empty 33*41-/62*+

So, the Postfix Expression is 33*41-/62*+

ii. Conversion of Postfix to Infix:

Following is an algorithm for Postfix to Infix conversion:
Step 1: While there are input symbol left.
Step 2: Read the next symbol from input.
Step 3: If the symbol is an operand, insert it onto the stack.
Step 4: Otherwise, the symbol is an operator.
Step 5: If there are fewer than 2 values on the stack, show error /* input
not sufficient values in the expression */
Step 6: Else,
a. Delete the top 2 values from the stack.
b. Put the operator, with the values as arguments and form a
string.
c. Encapsulate the resulted string with parenthesis.
d. Insert the resulted string back to stack.
Step 7: If there is only one value in the stack, that value in the stack is the
desired infix string.
102
Step 8: If there are more values in the stack, show error /* The user input
has too many values */
Example: Suppose we are converting efg-+he-sh-o+/* expression into
Infix.
Following table shows the evaluation of Postfix to Infix

efg-+he-sh-o+/* NULL
fg-+he-sh-o+/* “e”
g-+he-sh-o+/* “f”
“e”
-+he-sh-o+/* “g”
“f”
“e”
+he-sh-o+/* “f”-“g”
“e”
he-sh-o+/* “e+f-g”
e-sh-o+/* “h”
“e+f-g”
-sh-o+/* “e”
“h”
“e+f-g”
sh-o+/* “h-e”
“e+f-g”
h-o+/* “s”
“h-e”
“e+f-g”
-o+/* “h”
“s”
“h-e”
“e+f-g”
o+/* “h-s”
“h-e”
“e+f-g”
+/* “o”
“s-h”
“h-e”
“e+f-g”
/* “s-h+o”
“h-e”
“e+f-g”
* “(h-e)/(s-h+o)”
“e+f-g”
NULL “(e+f-g) * (h-e)/(s-h+o)”

So, the Infix Expression is (e+f-g) * (h-e)/(s-h+o)

103
iii.Prefix to Infix:
Algorithm for Prefix to Infix Conversion
Step 1: The reversed input string is inserted into a stack ->
prefixToInfix(stack)
Step 2: If stack is not empty,
a. Temp -> pop the stack
b. If temp is an operator,
Write a opening parenthesis “(“to show -> prefixToInfix(stack)
Write temp to show -> prefixToInfix(stack)
Write a closing parenthesis “)” to show
c. Else If temp is a space ->prefixToInfix(stack)
d. Else, write temp to show if stack.top! = space -
>prefixToInfix(stack)

Example: Suppose we are converting /-bc+-pqr expression from Prefix to

Infix.

Following table shows the evaluation of Prefix to Infix Conversion

Expression Stack
-bc+-pqr Empty
/-bc+-pq “q”
“r”
/-bc+- “p”
“q”
“r”
/-bc+ “p-q”
“r”
/-bc “p-q+r”
/-b “c”
“p-q+r”
/- “b”
“c”
“p-q+r”
/ “b-c”
“p-q+r”
NULL “((b-c)/((p-q) +r))”

So, the Infix Expression is ((b-c)/((p-q) +r))

5.4.4Memory management:
The assignment of memory takes place in contiguous memory blocks.
We call this stack memory allocation because the assignment takes place
in the function call stack.

104
 The size of the memory to be allocated is known to the compiler. When
a function is called, its variables get memory allocated on the stack.
When the function call is completed, the memory for the variables is
released. All this happens with the help of some predefined routines in the
compiler.
The user does not have to worry about memory allocation and release
of stack variables.
int main ()
{
// All these variables get memory
// allocated on stack
int f;
int a[10];
int c = 20;
int e[n];
}
The memory to be allocated to these variables is known to the compiler
and when the function is called, the allocation is done and when the
function terminates, the memory is released.

5.4.5 Recursion:
Some computer programming languages allow a module or function to
call itself. This technique is known as recursion.
In recursion, a function either calls itself directly or calls a
function that in turn calls the original function . The function is called
recursive function.
Example: a function calling itself.
int function (int value) {
if (value < 1)
return;
function (value - 1);
printf ("%d “, value);
}
Example a function that calls another function which in turn calls it
again.
int function1(int value1) {
if (value1 < 1)
return;
function2(value1 - 1);
printf ("%d ",value1);
}
int function2(int value2) {
function1(value2);

105
}
Properties:
A recursive function can go infinite like a loop. To avoid infinite running
of recursive function, there are two properties that a recursive function
must have
Base criteria There must be at least one base criteria or
condition, such that, when this condition is met the function stops
calling itself recursively.
Progressive approach The recursive calls should progress in
such a way that each time a recursive call is made it comes closer
to the base criteria.

5.5 SUMMARY

In this chapter we studied Operations on the Stack Memory

Representation like push (), pop (), peek (), isFull (), isEmpty ().
we are focused on array representation of stack; A stack is a data
structure that can be represented as an array. Let us learn more about
Array representation of a stack.
Also, we studied various applications of stack like evaluation of
arithmetic expression,
Matching Parenthesis, Infix and postfix operations, Memory management
and Recursion

5.6 REFERENCES

1. https://www.tutorialspoint.com/
2. https://www.studytonight.com/
3. https://prepinsta.com/
4. https://www.tutorialride.com/
5. https://www.faceprep.in/

5.7 UNIT END EXERCISE

1) Complete the class with all function definitions for a stack

class stack
{
int data [10];
int top;
public:
stack () {top=-1;}
void push ();
void pop ();
}

2) Change the following infix expression to postfix expression.

(A + B) *C+D/E-F
106
3) Evaluate the following postfix expression using a stack and show the
contents of stack after execution of each operation:
50,40, +,18, 14, -, *, +

4)Each node of a STACK contains the following information, in addition

to required pointer field:
i) Roll number of the student
ii) Age of the student
Give the structure of node for the linked stack in question TOP is a pointer
which points to the topmost nodeof the STACK. Write the following
functions.
i) PUSH () - To push a node to the stack which is allocated dynamically
ii) POP () - To remove a node from the stack and release the memory.

107
 6
QUEUE
Unit Structure

6.0 Objectives
6.1 Introduction
6.2 Queue
6.3 Operations on the Queue
6.4 Memory Representation of Queue
6.5 Array representation of queue
6.6 Linked List Representation of Queue
6.7 Circular Queue
6.8 Deque
6.9 Priority Queue
6.10 Applications of Queues
6.11 Summary
6.12 Bibliography
6.13 Unit End Exercise

6.0 OBJECTIVES

To understand the queue.

To be able to implement queue and deque.
To be able to recognize problem properties where queues, and deques
are appropriate data structures.
To be able to understand the applications of Queue.

6.1 INTRODUCTION

Queue is an abstract data structure, somewhat similar to Stacks.

Unlike stacks, a queue is open at both its ends. One end is always used to
insert data (enqueue) and the other is used to remove data (dequeue).
Queue follows First-In-First-Out methodology, i.e., the data item stored
first will be accessed first.

6.2 QUEUE

A Queue is a linear structure which follows a particular order in

which the operations are performed. The order is First In First Out (FIFO).

108
A good example of a queue is any queue of consumers for a resource
where the consumer that came first is served first. The difference
between stacks and queues is in removing. In a stack we remove the item
the most recently added; in a queue, we remove the item the least recently
added.

Like Stack, Queue is a linear structure which follows a particular

order in which the operations are performed. The order
is First In First Out (FIFO). A good example of queue is any queue of
consumers for a resource where the consumer that came first is served
first.

The difference between stacks and queues is in removing. In a

stack we remove the item the most recently added; in a queue, we remove
the item the least recently added.

6.3 OPERATIONS ON THE QUEUE

Queue operations may involve initializing or defining the queue,

utilizing it, and then completely erasing it from the memory. Here we shall
try to understand the basic operations associated with queues

enqueue() add (store) an item to the queue.

dequeue() remove (access) an item from the queue.

Few more functions are required to make the above-mentioned

queue operation efficient.

These are
peek() Gets the element at the front of the queue without removing it.
isfull() Checks if the queue is full.
isempty() Checks if the queue is empty.

In queue, we always dequeue (or access) data, pointed

by front pointer and while enqueing (or storing) data in the queue we take
help of rear pointer.

Enqueue Operation
Queues maintain two data pointers, front and rear. Therefore, its
operations are comparatively difficult to implement than that of stacks.

109
 The following steps should be taken to enqueue (insert) data into a
queue

Step 1 Check if the queue is full.

Step 2 If the queue is full, produce overflow error and exit.
Step 3 If the queue is not full, increment rear pointer to point the next
empty space.
Step 4 Add data element to the queue location, where the rear is
pointing.
Step 5 return success.

Implementation of enqueue() in C programming language

Example
int enqueue(int data)
if(isfull())
return 0;

rear = rear + 1;
queue[rear] = data;

return 1;
end procedure

Dequeue Operation
Accessing data from the queue is a process of two tasks access
the data where front is pointing and remove the data after access. The
following steps are taken to perform dequeue operation

Step 1 Check if the queue is empty.

Step 2 If the queue is empty, produce underflow error and exit.
Step 3 If the queue is not empty, access the data where front is pointing.
Step 4 Increment front pointer to point to the next available data
element.
Step 5 Return success.

Implementation of dequeue() in C programming language

Example
int dequeue() {
if(isempty())
return 0;

int data = queue[front];

front = front + 1;

return data;
}

110
6.4 MEMORY REPRESENTATION OF QUEUE

Like Stacks, Queues can also be represented in memory in two ways.

Using the contiguous memory like an array
Using the non-contiguous memory like a linked list

Using the Contiguous Memory like an Array

In this representation the Queue is implemented using the array.
Variables used in this case are
QUEUE- the name of the array storing queue elements.
FRONT- the index where the first element is stored in the array
representing the queue.
REAR- the index where the last element is stored in array representing the
queue.
MAX- defining that how many elements (maximum count) can be stored
in the array representing the queue.

Using the Non-Contiguous Memory like a Linked List

In this representation the queue is implemented using the dynamic
data structure Linked List.

Using linked list for creating a queue makes it flexible in terms of

size and storage.

You don’t have to define the maximum number of elements in the queue.
Pointers (links) to store addresses of nodes for defining a queue are.
FRONT- address of the first element of the Linked list storing the Queue.
REAR- address of the last element of the Linked list storing the Queue.

6.5 ARRAY REPRESENTATION OF QUEUE

We can easily represent queue by using linear arrays. There are

two variables i.e. front and rear, that are implemented in the case of every
queue. Front and rear variables point to the position from where insertions
and deletions are performed in a queue. Initially, the value of front and
queue is -1 which represents an empty queue. Array representation of a
queue containing 5 elements along with the respective values of front and
rear, is shown in the following figure.
111
 The above figure shows the queue of characters forming the
English word "HELLO". Since, No deletion is performed in the queue
till now, therefore the value of front remains -1 .

However, the value of rear increases by one every time an insertion

is performed in the queue. After inserting an element into the queue shown
in the above figure, the queue will look something like following. The
value of rear will become 5 while the value of front remains same.

After deleting an element, the value of front will increase from -1

to 0. however, the queue will look something like following.

6.6 LINKED LIST REPRESENTATION OF QUEUE

The array implementation can not be used for the large scale
applications where the queues are implemented.

One of the alternative of array implementation is linked list

implementation of queue.

112
 The storage requirement of linked representation of a queue with n
elements is o(n) while the time requirement for operations is o(1).

In a linked queue, each node of the queue consists of two parts i.e.
data part and the link part.

Each element of the queue points to its immediate next element in

the memory.

In the linked queue, there are two pointers maintained in the memory
i.e. front pointer and rear pointer. The front pointer contains the address of
the starting element of the queue while the rear pointer contains the
address of the last element of the queue.

Insertion and deletions are performed at rear and front end

respectively. If front and rear both are NULL, it indicates that the queue is
empty.

The linked representation of queue is shown in the following figure.

6.7 CIRCULAR QUEUE

A circular queue is the extended version of a regular queue where

the last element is connected to the first element. Thus forming a circle-
like structure.

The circular queue solves the major limitation of the normal queue.
In a normal queue, after a bit of insertion and deletion, there will be non-
usable empty space.

113
 Here, indexes 0 and 1 can only be used after resetting the queue
(deletion of all elements).

This reduces the actual size of the queue.

How Circular Queue Works

Circular Queue works by the process of circular increment i.e. when
we try to increment the pointer and we reach the end of the queue, we start
from the beginning of the queue.

Here, the circular increment is performed by modulo division with

the queue size. That is,

if REAR + 1 == 5 (overflow!), REAR = (REAR + 1)%5 = 0 (start of

queue)

6.8 DEQUE

A deque is also a special type of queue. In this queue, the enqueue

and dequeue operations take place at both front and rear. That means,
we can insert an item at both the ends and can remove an item from both
the ends. Thus, it may or may not adhere to the FIFO order:

It’s used to save browsing history, perform undo operations,

implement A-Steal job scheduling algorithm, or implement a stack or
implement a simple queue.

Further, it has two special cases: input-restricted

deque and output-restricted deque.

In the first case, the enqueue operation takes place only at the rear,
but the dequeue operation takes place at both rear and front:

114
 An input-restricted queue is useful when we need to remove an
item from the rear of the queue.

In the second case, the enqueue operation takes place at both rear
and front, but the dequeue operation takes place only at the front:

An output-restricted queue is handy when we need to insert an item

at the front of the queue.

6.9 PRIORITY QUEUE

Priority Queue is an extension of queue with following properties.

Every item has a priority associated with it.

An element with high priority is dequeued before an element with

low priority.

If two elements have the same priority, they are served according to
their order in the queue.

In the below priority queue, element with maximum ASCII value

will have the highest priority.

Atypical priority queue supports following operations.

115
insert(item, priority): Inserts an item with given priority.
get Highest Priority (): Returns the highest priority item.
delete Highest Priority(): Removes the highest priority item.

How to implement priority queue?

Using Array: A simple implementation is to use array of following
structure.
struct item {
int item;
int priority;
}
insert() operation can be implemented by adding an item at end of array in
O(1) time.

Applications of Priority Queue:

1) CPU Scheduling
2) Graph algorithms like Dijkstra’s shortest path algorithm, Prim’s
Minimum Spanning Tree, etc
3) All queue applications where priority is involved.

6.10 APPLICATIONS OF QUEUES

Queues are used in various applications in Computer Science-

Job scheduling tasks of CPU.
Printer’s Buffer to store printing commands initiated by a user.
Input commands sent to CPU by devices like Keyboard and
Mouse.
Document downloading from internet.
User Requests for call center services.
Order Queue for Online Food Delivery Chains.
Online Cab Booking applications.

6.11 SUMMARY

A queue is kind of like the opposite of a stack. Instead of having a

“last- in, first-- out” structure, it is “first- in, first- out”. Inserting A,
B, and then C, will make the first removed A, then B, then C. The first
item inserted is called the “head” of the queue, and the last item is the
“tail”.

116
6.12 BIBLIOGRAPHY

1. https://csveda.com/queue-applications-introduction-and-memory
representation/
2.
https://www.tutorialspoint.com/data_structures_algorithms/dsa_queue.htm
3. https://www.geeksforgeeks.org/queue-set-1introduction-and-array-
implementation/
4.https://www.javatpoint.com/array-representation-of-queue
5.https://www.programiz.com/dsa/circular-queue
6.https://www.baeldung.com/cs/types-of-queues

6.13 UNIT END EXERCISE

1. Explain Queue data structure in details?

2. Explain briefly operations on queue?
3. What is circular queue ? how to implement it?
4. Write short notes on :
a) Priority queue
b) Dequeue
c) Enqueue
5) Explain Applications of Queue and Dequeue

117