UNIT-I:

Introduction: Definition of data structure, types and overview of data

structures. Algorithm: Preliminaries of algorithm, Algorithm analysis and
complexity. Stacks and Queues: Stack Representation using Arrays,
operations on stack, Applications of stacks - Factorial Calculation, Infix to
postfix Transformation, Evaluating Arithmetic Expressions. Queue
Representation using Arrays, operations on queues, Applications of queues,
Circular queues, Priority queues, Implementation of queue using stack

Part-A-Introduction: Definition of Data Structure, Types and

overview of Data Structures

Introduction to Data Structures

Since the invention of computers, people have been using the term "Data" to refer
to Computer Information, either transmitted or stored. However, there is data that
exists in order types as well. Data can be numbers or texts written on a piece of
paper, in the form of bits and bytes stored inside the memory of electronic devices,
or facts stored within a person's mind. As the world started modernizing, this data
became a significant aspect of everyone's day-to-day life, and various
implementations allowed them to store it differently.

Data is a collection of facts and figures or a set of values or values of a specific

format that refers to a single set of item values. The data items are then classified
into sub-items, which is the group of items that are not known as the simple primary
form of the item.

Let us consider an example where an employee name can be broken down into
three sub-items: First, Middle, and Last. However, an ID assigned to an employee
will generally be considered a single item.

Figure 1: Representation of Data Items

In the example mentioned above, the items such as ID, Age, Gender, First, Middle,
Last, Street, Locality, etc., are elementary data items. In contrast, the Name and the
Address are group data items.

1
What is Data Structure?

Data Structure is a branch of Computer Science. The study of data structure allows
us to understand the organization of data and the management of the data flow in
order to increase the efficiency of any process or program. Data Structure is a
particular way of storing and organizing data in the memory of the computer so that
these data can easily be retrieved and efficiently utilized in the future when
required. The data can be managed in various ways, like the logical or
mathematical model for a specific organization of data is known as a data structure.

The scope of a particular data model depends on two factors:

1. First, it must be loaded enough into the structure to reflect the definite
correlation of the data with a real-world object.
2. Second, the formation should be so straightforward that one can adapt to
process the data efficiently whenever necessary.

Some examples of Data Structures are Arrays, Linked Lists, Stack, Queue, Trees,
etc. Data Structures are widely used in almost every aspect of Computer Science,
i.e., Compiler Design, Operating Systems, Graphics, Artificial Intelligence, and
many more.

Data Structures are the main part of many Computer Science Algorithms as they
allow the programmers to manage the data in an effective way. It plays a crucial
role in improving the performance of a program or software, as the main objective
of the software is to store and retrieve the user's data as fast as possible.

Basic Terminologies related to Data Structures

Data Structures are the building blocks of any software or program. Selecting the
suitable data structure for a program is an extremely challenging task for a
programmer.

1. Data: We can define data as an elementary value or a collection of values.

For example, the Employee's name and ID are the data related to the
Employee.
2. Data Items: A Single unit of value is known as Data Item.
3. Group Items: Data Items that have subordinate data items are known as
Group Items. For example, an employee's name can have a first, middle, and
last name.
4. Elementary Items: Data Items that are unable to divide into sub-items are
known as Elementary Items. For example, the ID of an Employee.
5. Entity and Attribute: A class of certain objects is represented by an Entity.
It consists of different Attributes. Each Attribute symbolizes the specific
property of that Entity. For example,

2
 Attributes ID Name Gender Job Title

Values 1234 Stacey M. Hill Female Software Developer

Entities with similar attributes form an Entity Set. Each attribute of an entity set has
a range of values, the set of all possible values that could be assigned to the specific
attribute.

The term "information" is sometimes utilized for data with given attributes of
meaningful or processed data.

1. Field: A single elementary unit of information symbolizing the Attribute of

an Entity is known as Field.
2. Record: A collection of different data items are known as a Record. For
example, if we talk about the employee entity, then its name, id, address,
and job title can be grouped to form the record for the employee.
3. File: A collection of different Records of one entity type is known as a File.
For example, if there are 100 employees, there will be 25 records in the
related file containing data about each employee.

Understanding the Need for Data Structures

As applications are becoming more complex and the amount of data is increasing
every day, which may lead to problems with data searching, processing speed,
multiple requests handling, and many more. Data Structures support different
methods to organize, manage, and store data efficiently. With the help of Data
Structures, we can easily traverse the data items. Data Structures provide
Efficiency, Reusability, and Abstraction.

Why should we learn Data Structures?

1. Data Structures and Algorithms are two of the key aspects of Computer
Science.
2. Data Structures allow us to organize and store data, whereas Algorithms
allow us to process that data meaningfully.
3. Learning Data Structures and Algorithms will help us become better
Programmers.
4. We will be able to write code that is more effective and reliable.
5. We will also be able to solve problems more quickly and efficiently.

Understanding the Objectives of Data Structures

Data Structures satisfy two complementary objectives:

3
 1. Correctness: Data Structures are designed to operate correctly for all kinds
of inputs based on the domain of interest. In order words, correctness forms
the primary objective of Data Structure, which always depends upon the
problems that the Data Structure is meant to solve.
2. Efficiency: Data Structures also requires to be efficient. It should process
the data quickly without utilizing many computer resources like memory
space. In a real-time state, the efficiency of a data structure is a key factor in
determining the success and failure of the process.

Understanding some Key Features of Data Structures

Some of the Significant Features of Data Structures are:

1. Robustness: Generally, all computer programmers aim to produce

software that yields correct output for every possible input, along with
efficient execution on all hardware platforms. This type of robust software
must manage both valid and invalid inputs.
2. Adaptability: Building software applications like Web Browsers, Word
Processors, and Internet Search Engine include huge software systems that
require correct and efficient working or execution for many years.
Moreover, software evolves due to emerging technologies or ever-
changing market conditions.
3. Reusability: The features like Reusability and Adaptability go hand in hand.
It is known that the programmer needs many resources to build any
software, making it a costly enterprise. However, if the software is
developed in a reusable and adaptable way, then it can be applied in most
future applications. Thus, by executing quality data structures, it is possible
to build reusable software, which appears to be cost-effective and
timesaving.

Classification of Data Structures

A Data Structure delivers a structured set of variables related to each other in

various ways. It forms the basis of a programming tool that signifies the relationship
between the data elements and allows programmers to process the data efficiently.

We can classify Data Structures into two categories:

1. Primitive Data Structure

2. Non-Primitive Data Structure

The following figure shows the different classifications of Data Structures.

4
Figure 2: Classifications of Data Structures

Primitive Data Structures

1. Primitive Data Structures are the data structures consisting of the numbers
and the characters that come in-built into programs.
2. These data structures can be manipulated or operated directly by machine-
level instructions.
3. Basic data types like Integer, Float, Character, and Boolean come under
the Primitive Data Structures.
4. These data types are also called Simple data types, as they contain
characters that can't be divided further

Non-Primitive Data Structures

1. Non-Primitive Data Structures are those data structures derived from

Primitive Data Structures.
2. These data structures can't be manipulated or operated directly by machine-
level instructions.
3. The focus of these data structures is on forming a set of data elements that is
either homogeneous (same data type) or heterogeneous (different data
types).

5
 4. Based on the structure and arrangement of data, we can divide these data
structures into two sub-categories -
a. Linear Data Structures
b. Non-Linear Data Structures

Linear Data Structures

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

Based on memory allocation, the Linear Data Structures are further classified into
two types:

1. Static Data Structures: The data structures having a fixed size are known as
Static Data Structures. The memory for these data structures is allocated at
the compiler time, and their size cannot be changed by the user after being
compiled; however, the data stored in them can be altered.
The Array is the best example of the Static Data Structure as they have a
fixed size, and its data can be modified later.
2. Dynamic Data Structures: The data structures having a dynamic size are
known as Dynamic Data Structures. The memory of these data structures is
allocated at the run time, and their size varies during the run time of the
code. Moreover, the user can change the size as well as the data elements
stored in these data structures at the run time of the code.
Linked Lists, Stacks, and Queues are common examples of dynamic data
structures

Types of Linear Data Structures

The following is the list of Linear Data Structures that we generally use:

1. Arrays

An Array is a data structure used to collect multiple data elements of the same data
type into one variable. Instead of storing multiple values of the same data types in
separate variable names, we could store all of them together into one variable. This
statement doesn't imply that we will have to unite all the values of the same data
type in any program into one array of that data type. But there will often be times
when some specific variables of the same data types are all related to one another
in a way appropriate for an array.

An Array is a list of elements where each element has a unique place in the list. The
data elements of the array share the same variable name; however, each carries a

6
different index number called a subscript. We can access any data element from
the list with the help of its location in the list. Thus, the key feature of the arrays to
understand is that the data is stored in contiguous memory locations, making it
possible for the users to traverse through the data elements of the array using their
respective indexes.

Figure 3. An Array

Arrays can be classified into different types:

a. One-Dimensional Array: An Array with only one row of data elements is

known as a One-Dimensional Array. It is stored in ascending storage location.
b. Two-Dimensional Array: An Array consisting of multiple rows and
columns of data elements is called a Two-Dimensional Array. It is also known
as a Matrix.
c. Multidimensional Array: We can define Multidimensional Array as an
Array of Arrays. Multidimensional Arrays are not bounded to two indices or
two dimensions as they can include as many indices are per the need.

Some Applications of Array:

a. We can store a list of data elements belonging to the same data type.
b. Array acts as an auxiliary storage for other data structures.
c. The array also helps store data elements of a binary tree of the fixed count.
d. Array also acts as a storage of matrices.

2. Linked Lists

A Linked List is another example of a linear data structure used to store a

collection of data elements dynamically. Data elements in this data structure are
represented by the Nodes, connected using links or pointers. Each node contains
two fields, the information field consists of the actual data, and the pointer field
consists of the address of the subsequent nodes in the list. The pointer of the last
node of the linked list consists of a null pointer, as it points to nothing. Unlike the
Arrays, the user can dynamically adjust the size of a Linked List as per the
requirements.

7
Figure 4. A Linked List

Linked Lists can be classified into different types:

a. Singly Linked List: A Singly Linked List is the most common type of Linked
List. Each node has data and a pointer field containing an address to the next node.
b. Doubly Linked List: A Doubly Linked List consists of an information field
and two pointer fields. The information field contains the data. The first
pointer field contains an address of the previous node, whereas another
pointer field contains a reference to the next node. Thus, we can go in both
directions (backward as well as forward).
c. Circular Linked List: The Circular Linked List is similar to the Singly
Linked List. The only key difference is that the last node contains the address
of the first node, forming a circular loop in the Circular Linked List.

Some Applications of Linked Lists:

a. The Linked Lists help us implement stacks, queues, binary trees, and graphs
of predefined size.
b. We can also implement Operating System's function for dynamic memory
management.
c. Linked Lists also allow polynomial implementation for mathematical
operations.
d. We can use Circular Linked List to implement Operating Systems or
application functions that Round Robin execution of tasks.
e. Circular Linked List is also helpful in a Slide Show where a user requires to
go back to the first slide after the last slide is presented.
f. Doubly Linked List is utilized to implement forward and backward buttons
in a browser to move forward and backward in the opened pages of a
website.

3. Stacks

A Stack is a Linear Data Structure that follows the LIFO (Last In, First Out) principle
that allows operations like insertion and deletion from one end of the Stack, i.e.,

8
Top. Stacks can be implemented with the help of contiguous memory, an Array,
and non-contiguous memory, a Linked List. Real-life examples of Stacks are piles
of books, a deck of cards, piles of money, and many more.

Figure 5. A Real-life Example of Stack

The above figure represents the real-life example of a Stack where the operations
are performed from one end only, like the insertion and removal of new books from
the top of the Stack. It implies that the insertion and deletion in the Stack can be
done only from the top of the Stack. We can access only the Stack's tops at any
given time.

The primary operations in the Stack are as follows:

a. Push: Operation to insert a new element in the Stack is termed as Push

Operation.
b. Pop: Operation to remove or delete elements from the Stack is termed as
Pop Operation.

9
Figure 6. A Stack

Some Applications of Stacks:

a. The Stack is used as a Temporary Storage Structure for recursive operations.

b. Stack is also utilized as Auxiliary Storage Structure for function calls, nested
operations, and deferred/postponed functions.
c. We can manage function calls using Stacks.
d. Stacks are also utilized to evaluate the arithmetic expressions in different
programming languages.
e. Stacks are also helpful in converting infix expressions to postfix expressions.
f. Stacks allow us to check the expression's syntax in the programming
environment.
g. We can match parenthesis using Stacks.
h. Stacks can be used to reverse a String.
i. Stacks are helpful in solving problems based on backtracking.
j. We can use Stacks in depth-first search in graph and tree traversal.
k. Stacks are also used in Operating System functions.
l. Stacks are also used in UNDO and REDO functions in an edit.

4. Queues

A Queue is a linear data structure similar to a Stack with some limitations on the
insertion and deletion of the elements. The insertion of an element in a Queue is

10
done at one end, and the removal is done at another or opposite end. Thus, we can
conclude that the Queue data structure follows FIFO (First In, First Out) principle to
manipulate the data elements. Implementation of Queues can be done using
Arrays, Linked Lists, or Stacks. Some real-life examples of Queues are a line at the
ticket counter, an escalator, a car wash, and many more.

Figure 7. A Real-life Example of Queue

The above image is a real-life illustration of a movie ticket counter that can help us
understand the Queue where the customer who comes first is always served first.
The customer arriving last will undoubtedly be served last. Both ends of the Queue
are open and can execute different operations. Another example is a food court
line where the customer is inserted from the rear end while the customer is
removed at the front end after providing the service they asked for.

The following are the primary operations of the Queue:

a. Enqueue: The insertion or Addition of some data elements to the Queue is

called Enqueue. The element insertion is always done with the help of the
rear pointer.
b. Dequeue: Deleting or removing data elements from the Queue is termed
Dequeue. The deletion of the element is always done with the help of the
front pointer.

11
Figure 8. A Queue

Some Applications of Queues:

a. Queues are generally used in the breadth search operation in Graphs.

b. Queues are also used in Job Scheduler Operations of Operating Systems,
like a keyboard buffer queue to store the keys pressed by users and a print
buffer queue to store the documents printed by the printer.
c. Queues are responsible for CPU scheduling, Job scheduling, and Disk
Scheduling.
d. Priority Queues are utilized in file-downloading operations in a browser.
e. Queues are also used to transfer data between peripheral devices and the
CPU.
f. Queues are also responsible for handling interrupts generated by the User
Applications for the CPU.

Non-Linear Data Structures

Non-Linear Data Structures are data structures where the data elements are not
arranged in sequential order. Here, the insertion and removal of data are not
feasible in a linear manner. There exists a hierarchical relationship between the
individual data items.

Types of Non-Linear Data Structures

The following is the list of Non-Linear Data Structures that we generally use:

1. Trees

A Tree is a Non-Linear Data Structure and a hierarchy containing a collection of

nodes such that each node of the tree stores a value and a list of references to other
nodes (the "children").

The Tree data structure is a specialized method to arrange and collect data in the
computer to be utilized more effectively. It contains a central node, structural

12
nodes, and sub-nodes connected via edges. We can also say that the tree data
structure consists of roots, branches, and leaves connected.

Figure 9. A Tree

Trees can be classified into different types:

a. Binary Tree: A Tree data structure where each parent node can have at
most two children is termed a Binary Tree.
b. Binary Search Tree: A Binary Search Tree is a Tree data structure where
we can easily maintain a sorted list of numbers.
c. AVL Tree: An AVL Tree is a self-balancing Binary Search Tree where each
node maintains extra information known as a Balance Factor whose value is
either -1, 0, or +1.
d. B-Tree: A B-Tree is a special type of self-balancing Binary Search Tree
where each node consists of multiple keys and can have more than two
children.

Some Applications of Trees:

a. Trees implement hierarchical structures in computer systems like

directories and file systems.
b. Trees are also used to implement the navigation structure of a website.
c. We can generate code like Huffman's code using Trees.
d. Trees are also helpful in decision-making in Gaming applications.

13
 e. Trees are responsible for implementing priority queues for priority-based
OS scheduling functions.
f. Trees are also responsible for parsing expressions and statements in the
compilers of different programming languages.
g. We can use Trees to store data keys for indexing for Database Management
System (DBMS).
h. Spanning Trees allows us to route decisions in Computer and
Communications Networks.
i. Trees are also used in the path-finding algorithm implemented in Artificial
Intelligence (AI), Robotics, and Video Games Applications.

2. Graphs

A Graph is another example of a Non-Linear Data Structure comprising a finite

number of nodes or vertices and the edges connecting them. The Graphs are
utilized to address problems of the real world in which it denotes the problem area
as a network such as social networks, circuit networks, and telephone networks.
For instance, the nodes or vertices of a Graph can represent a single user in a
telephone network, while the edges represent the link between them via
telephone.

The Graph data structure, G is considered a mathematical structure comprised of

a set of vertices, V and a set of edges, E as shown below:

G = (V,E)

14
Figure 10. A Graph

The above figure represents a Graph having seven vertices A, B, C, D, E, F, G, and

ten edges [A, B], [A, C], [B, C], [B, D], [B, E], [C, D], [D, E], [D, F], [E, F], and [E, G].

Depending upon the position of the vertices and edges, the Graph s can be
classified into different types:

a. Null Graph: A Graph with an empty set of edges is termed a Null Graph.
b. Trivial Graph: A Graph having only one vertex is termed a Trivial
Graph.
c. Simple Graph: A Graph with neither self-loops nor multiple edges is
known as a Simple Graph.
d. Multi Graph: A Graph is said to be Multi if it consists of multiple edges
but no self-loops.
e. Pseudo Graph: A Graph with self-loops and multiple edges is termed a
Pseudo Graph.
f. Non-Directed Graph: A Graph consisting of non-directed edges is
known as a Non-Directed Graph.
g. Directed Graph: A Graph consisting of the directed edges between the
vertices is known as a Directed Graph.
h. Connected Graph: A Graph with at least a single path between every
pair of vertices is termed a Connected Graph.
i. Disconnected Graph: A Graph where there does not exist any path
between at least one pair of vertices is termed a Disconnected Graph.
j. Regular Graph: A Graph where all vertices have the same degree is
termed a Regular Graph.
k. Complete Graph: A Graph in which all vertices have an edge between
every pair of vertices is known as a Complete Graph.
l. Cycle Graph: A Graph is said to be a Cycle if it has at least three vertices
and edges that form a cycle.
m. Cyclic Graph: A Graph is said to be Cyclic if and only if at least one
cycle exists.
n. Acyclic Graph: A Graph having zero cycles is termed an Acyclic Graph.
o. Finite Graph: A Graph with a finite number of vertices and edges is
known as a Finite Graph.
p. Infinite Graph: A Graph with an infinite number of vertices and edges
is known as an Infinite Graph.

15
 q. Bipartite Graph: A Graph where the vertices can be divided into
independent sets A and B, and all the vertices of set A should only be
connected to the vertices present in set B with some edges is termed a
Bipartite Graph.
r. Planar Graph: A Graph is said to be a Planar if we can draw it in a single
plane with two edges intersecting each other.
s. Euler Graph: A Graph is said to be Euler if and only if all the vertices are
even degrees.
t. Hamiltonian Graph: A Connected Graph consisting of a Hamiltonian
circuit is known as a Hamiltonian Graph.

Some Applications of Graphs:

a. Graphs help us represent routes and networks in transportation, travel, and

communication applications.
b. Graphs are used to display routes in GPS.
c. Graphs also help us represent the interconnections in social networks and
other network-based applications.
d. Graphs are utilized in mapping applications.
e. Graphs are responsible for the representation of user preference in e -
commerce applications.
f. Graphs are also used in Utility networks in order to identify the problems
posed to local or municipal corporations.
g. Graphs also help to manage the utilization and availability of resources in an
organization.
h. Graphs are also used to make document link maps of the websites in order
to display the connectivity between the pages through hyperlinks.
i. Graphs are also used in robotic motions and neural networks.

Basic Operations of Data Structures

1. Traversal: Traversing a data structure means accessing each data element

exactly once so it can be administered. For example, traversing is required
while printing the names of all the employees in a department.
2. Search: Search is another data structure operation which means to find the
location of one or more data elements that meet certain constraints. Such a
data element may or may not be present in the given set of data elements.

16
 For example, we can use the search operation to find the names of all the
employees who have the experience of more than 5 years.
3. Insertion: Insertion means inserting or adding new data elements to the
collection. For example, we can use the insertion operation to add the details
of a new employee the company has recently hired.
4. Deletion: Deletion means to remove or delete a specific data element from
the given list of data elements. For example, we can use the deleting
operation to delete the name of an employee who has left the job.
5. Sorting: Sorting means to arrange the data elements in either Ascending or
Descending order depending on the type of application. For example, we
can use the sorting operation to arrange the names of employees in a
department in alphabetical order or estimate the top three performers of the
month by arranging the performance of the employees in descending order
and extracting the details of the top three.
6. Merge: Merge means to combine data elements of two sorted lists in order
to form a single list of sorted data elements.
7. Create: Create is an operation used to reserve memory for the data
elements of the program. We can perform this operation using a declaration
statement. The creation of data structure can take place either during the
following:
a. Compile-time
b. Run-time
For example, the malloc() function is used in C Language to create
data structure.
8. Selection: Selection means selecting a particular data from the available
data. We can select any particular data by specifying conditions inside the
loop.
9. Update: The Update operation allows us to update or modify the data in the
data structure. We can also update any particular data by specifying some
conditions inside the loop, like the Selection operation.
10. Splitting: The Splitting operation allows us to divide data into various
subparts decreasing the overall process completion time.

Some Applications of Data Structures

1. Data Structures help in the organization of data in a computer's memory.

2. Data Structures also help in representing the information in databases.

17
 3. Data Structures allows the implementation of algorithms to search through
data (For example, search engine).
4. We can use the Data Structures to implement the algorithms to manipulate
data (For example, word processors).
5. We can also implement the algorithms to analyse data using Data Structures
(For example, data miners).
6. Data Structures support algorithms to generate the data (For example, a
random number generator).
7. Data Structures also support algorithms to compress and decompress the
data (For example, a zip utility).
8. We can also use Data Structures to implement algorithms to encrypt and
decrypt the data (For example, a security system).
9. With the help of Data Structures, we can build software that can manage files
and directories (For example, a file manager).
10. We can also develop software that can render graphics using Data
Structures. (For example, a web browser or 3D rendering software).

Part-B- Algorithm: Preliminaries of algorithm, Algorithm analysis

and complexity
Definition: - An algorithm is a Step By Step process to solve a problem, where each
step indicates an intermediate task. Algorithm contains finite number of steps that
leads to the solution of the problem.
Properties /Characteristics of an Algorithm: -
Input-Output: - Algorithm takes ‘0’ or more input and produces the required output.
This is the basic characteristic of an algorithm.
Finiteness: - An algorithm must terminate in countable number of steps.
Definiteness: Each step of an algorithm must be stated clearly and unambiguously.
Effectiveness: Each and every step in an algorithm can be converted in to
programming language statement.
Generality: Algorithm is generalized one. It works on all set of inputs and provides
the required output. In other words, it is not restricted to a single input value.
Categories of Algorithm:
Based on the different types of steps in an Algorithm, it can be divided into three
categories, namely
➢ Sequence
➢ Selection and

18
 ➢ Iteration
Sequence: The steps described in an algorithm are performed successively one by
one without skipping any step. The sequence of steps defined in an algorithm should
be simple and easy to understand. Each instruction of such an algorithm is executed,
because no selection procedure or conditional branching exists in a sequence
algorithm.
Example:
// adding two numbers
Step 1: start
Step 2: read a,b
Step 3: Sum=a+b
Step 4: write Sum
Step 5: stop
Selection: The sequence type of algorithms are not sufficient to solve the problems,
which involves decision and conditions. In order to solve the problem which involve
decision making or option selection, we go for Selection type of algorithm. The
general format of Selection type of statement is as shown below:
if(condition)
Statement-1;
else
Statement-2;
The above syntax specifies that if the condition is true, statement-1 will be executed
otherwise statement-2 will be executed. In case the operation is unsuccessful. Then
sequence of algorithm should be changed/ corrected in such a way that the system
will reexecute until the operation is successful
1.Write an algorithm for roots of a Quadratic Equation?
Example: Roots of a quadratic Equation
Step 1 : start
Step 2 : read a,b,c
Step 3 : if (a= 0) then step 4 else step 5
Step 4 : Write “ Given equation is a linear equation “
Step 5 : d=(b * b) _ (4 *a *c)
Step 6 : if ( d>0) then step 7 else step8
Step 7 : Write “ Roots are real and Distinct”
Step 8: if(d=0) then step 9 else step 10

19
Step 9: Write “Roots are real and equal”
Step 10: Write “ Roots are Imaginary”
Step 11: stop
Iteration: Iteration type algorithms are used in solving the problems which involves
repetition of statement. In this type of algorithms, a particular number of statements
are repeated ‘n’ no. of times.
Example1:
Step 1 : start
Step 2 : read n
Step 3 : repeat step 4 until n>0
Step 4 : (a) r=n mod 10
(b) s=s+r
(c) n=n/10
Step 5 : write s
Step 6 : stop
Performance Analysis an Algorithm:
The Efficiency of an Algorithm can be measured by the following metrics.
i.Time Complexity:
The amount of time required for an algorithm to complete its execution is its time
complexity. An algorithm is said to be efficient if it takes the minimum (reasonable)
amount of time to complete its execution.
ii. Space Complexity:
The amount of space occupied by an algorithm is known as Space Complexity. An
algorithm is said to be efficient if it occupies less space and required the minimum
amount of time to complete its execution.
Part - C:
Stacks and Queues: Stack Representation using Arrays, operations on
stack, Applications of stacks - Factorial Calculation, Infix to postfix
Transformation, Evaluating Arithmetic Expressions. Queue
Representation using Arrays, operations on queues, Applications of
queues, Circular queues, Priority queues, Implementation of queue using
stack

20
 UNIT-II
STACKS AND QUEUES
STACKS
A Stack is linear data structure. A stack is a list of elements in which an element may be
inserted or deleted only at one end, called the top of the stack. Stack principle is LIFO (last
in, first out). Which element inserted last on to the stack that element deleted first from the
stack.

As the items can be added or removed only from the top i.e. the last item to be added to a
stack is the first item to be removed.

Real life examples of stacks are:

Operations on stack:

The two basic operations associated with stacks are:

1. Push
2. Pop

While performing push and pop operations the following test must be conducted on the
stack.
a) Stack is empty or not b) stack is full or not

1. Push: Push operation is used to add new elements in to the stack. At the time of addition
first check the stack is full or not. If the stack is full it generates an error message "stack
overflow".

2. Pop: Pop operation is used to delete elements from the stack. At the time of deletion first
check the stack is empty or not. If the stack is empty it generates an error message "stack
underflow".

All insertions and deletions take place at the same end, so the last element added to
the stack will be the first element removed from the stack. When a stack is created, the
stack base remains fixed while the stack top changes as elements are added and removed.
The most accessible element is the top and the least accessible element is the bottom of the
stack.

21
Representation of Stack (or) Implementation of stack:
The stack should be represented in two ways:
1. Stack using array
2. Stack using linked list

1. Stack using array:

Let us consider a stack with 6 elements capacity. This is called as the size of the stack. The
number of elements to be added should not exceed the maximum size of the stack. If we
attempt to add new element beyond the maximum size, we will encounter a stack overflow
condition. Similarly, you cannot remove elements beyond the base of the stack. If such is
the case, we will reach a stack underflow condition.

1.push():When an element is added to a stack, the operation is performed by push(). Below

Figure shows the creation of a stack and addition of elements using push().

Initially top=-1, we can insert an element in to the stack, increment the top value i.e
top=top+1. We can insert an element in to the stack first check the condition is stack is full
or not. i.e top>=size-1. Otherwise add the element in to the stack.

void push() Algorithm: Procedure for push():

{
int x; Step 1: START
if(top >= n-1) Step 2: if top>=size-1 then
{ Write “ Stack is Overflow”
printf("\n\nStack Step 3: Otherwise
Overflow.."); 3.1: read data value ‘x’
return; 3.2: top=top+1;
} 3.3: stack[top]=x;
else Step 4: END
{
printf("\n\nEnter data: ");
scanf("%d", &x);
stack[top] = x;
top = top + 1;
printf("\n\nData Pushed into
the stack");
}
}

22
2.Pop(): When an element is taken off from the stack, the operation is performed by pop().
Below figure shows a stack initially with three elements and shows the deletion of elements
using pop().

We can insert an element from the stack, decrement the top value i.e top=top-1.
We can delete an element from the stack first check the condition is stack is empty or not.
i.e top==-1. Otherwise remove the element from the stack.

Void pop() Algorithm: procedure pop():

{ Step 1: START
If(top==-1) Step 2: if top==-1 then
{ Write “Stack is Underflow”
Printf(“Stack is Underflow”); Step 3: otherwise
} 3.1: print “deleted element”
else 3.2: top=top-1;
{ Step 4: END
printf(“Delete data %d”,stack[top]);
top=top-1;
}
}

3.display(): This operation performed display the elements in the stack. We display the
element in the stack check the condition is stack is empty or not i.e top==-1.Otherwise
display the list of elements in the stack.

23
 void display() Algorithm: procedure pop():
{ Step 1: START
If(top==-1) Step 2: if top==-1 then
{ Write “Stack is Underflow”
Printf(“Stack is Underflow”); Step 3: otherwise
} 3.1: print “Display elements are”
else 3.2: for top to 0
{ Print ‘stack[i]’
printf(“Display elements are:); Step 4: END
for(i=top;i>=0;i--)
printf(“%d”,stack[i]);
}
}

Source code for stack operations, using array:

#include<stdio.h>
#inlcude<conio.h>
int stack[100],choice,n,top,x,i;
void push(void);
void pop(void);
void display(void);
int main()
{
//clrscr();
top=-1;
printf("\n Enter the size of STACK[MAX=100]:");
scanf("%d",&n);
printf("\n\t STACK OPERATIONS USING ARRAY");
printf("\n\t--------------------------------");
printf("\n\t 1.PUSH\n\t 2.POP\n\t 3.DISPLAY\n\t 4.EXIT");
do
{
printf("\n Enter the Choice:");
scanf("%d",&choice);
switch(choice)
{
case 1:
{
push();
break;
}
case 2:
{
pop();
break;
}
case 3:
{

10

24
 display();
break;
}
case 4:
{
printf("\n\t EXIT POINT ");
break;
}
default:
{
printf ("\n\t Please Enter a Valid Choice(1/2/3/4)");
}

}
}
while(choice!=4);
return 0;
}
void push()
{
if(top>=n-1)
{
printf("\n\tSTACK is over flow");

}
else
{
printf(" Enter a value to be pushed:");
scanf("%d",&x);
top++;
stack[top]=x;
}
}
void pop()
{
if(top<=-1)
{
printf("\n\t Stack is under flow");
}
else
{
printf("\n\t The popped elements is %d",stack[top]);
top--;
}
}
void display()
{
if(top>=0)
{

11

25
 printf("\n The elements in STACK \n");
for(i=top; i>=0; i--)
printf("\n%d",stack[i]);
printf("\n Press Next Choice");
}
else
{
printf("\n The STACK is empty");
}

2. Stack using Linked List:

We can represent a stack as a linked list. In a stack push and pop operations are performed
at one end called top. We can perform similar operations at one end of list using top
pointer. The linked stack looks as shown in figure.

Applications of stack:
1. Stack is used by compilers to check for balancing of parentheses, brackets and braces.
2. Stack is used to evaluate a postfix expression.
3. Stack is used to convert an infix expression into postfix/prefix form.
4. In recursion, all intermediate arguments and return values are stored on the processor’s
stack.
5. During a function call the return address and arguments are pushed onto a stack and on
return they are popped off.

Converting and evaluating Algebraic expressions:

An algebraic expression is a legal combination of operators and operands. Operand is the
quantity on which a mathematical operation is performed. Operand may be a variable like x,
y, z or a constant like 5, 4, 6 etc. Operator is a symbol which signifies a mathematical or
logical operation between the operands. Examples of familiar operators include +, -, *, /, ^
etc.

12

26
An algebraic expression can be represented using three different notations. They are infix,
postfix and prefix notations:
Infix: It is the form of an arithmetic expression in which we fix (place) the arithmetic
operator in between the two operands.
Example: A + B
Prefix: It is the form of an arithmetic notation in which we fix (place) the arithmetic
operator before (pre) its two operands. The prefix notation is called as polish notation.
Example: + A B

Postfix: It is the form of an arithmetic expression in which we fix (place) the arithmetic
operator after (post) its two operands. The postfix notation is called as suffix notation and is
also referred to reverse polish notation.
Example: A B +
Conversion from infix to postfix:
Procedure to convert from infix expression to postfix expression is as follows:
1. Scan the infix expression from left to right.
2. a) If the scanned symbol is left parenthesis, push it onto the stack.
b) If the scanned symbol is an operand, then place directly in the postfix expression
(output).
c) If the symbol scanned is a right parenthesis, then go on popping all the items from the
stack and place them in the postfix expression till we get the matching left parenthesis.
d) If the scanned symbol is an operator, then go on removing all the operators from the
stack and place them in the postfix expression, if and only if the precedence of the
operator which is on the top of the stack is greater than (or greater than or equal) to the
precedence of the scanned operator and push the scanned operator onto the stack
otherwise, push the scanned operator onto the stack.
The three important features of postfix expression are:
1. The operands maintain the same order as in the equivalent infix expression.
2. The parentheses are not needed to designate the expression unambiguously.
3. While evaluating the postfix expression the priority of the operators is no longer relevant.

We consider five binary operations: +, -, *, / and $ or ↑ (exponentiation). For these binary

operations, the following in the order of precedence (highest to lowest):

13

27
Evaluation of postfix expression:
The postfix expression is evaluated easily by the use of a stack.
1. When a number is seen, it is pushed onto the stack;
2. When an operator is seen, the operator is applied to the two numbers that are
popped from the stack and the result is pushed onto the stack.
3. When an expression is given in postfix notation, there is no need to know any
precedence rules; this is our obvious advantage.

14

28
15

29
 QUEUE
A queue is linear data structure and collection of elements. A queue is another special kind
of list, where items are inserted at one end called the rear and deleted at the other end
called the front. The principle of queue is a “FIFO” or “First-in-first-out”.
Queue is an abstract data structure. A queue is a useful data structure in programming. It is
similar to the ticket queue outside a cinema hall, where the first person entering the queue
is the first person who gets the ticket.
A real-world example of queue can be a single-lane one-way road, where the vehicle enters
first, exits first.

More real-world examples can be seen as queues at the ticket windows and bus-stops and
our college library.

The operations for a queue are analogues to those for a stack; the difference is that the
insertions go at the end of the list, rather than the beginning.
Operations on QUEUE:
A queue is an object or more specifically an abstract data structure (ADT) that allows the
following operations:
 Enqueue or insertion: which inserts an element at the end of the queue.
 Dequeue or deletion: which deletes an element at the start of the queue.
Queue operations work as follows:
1. Two pointers called FRONT and REAR are used to keep track of the first and last
elements in the queue.
2. When initializing the queue, we set the value of FRONT and REAR to 0.
3. On enqueing an element, we increase the value of REAR index and place the new
element in the position pointed to by REAR.
4. On dequeueing an element, we return the value pointed to by FRONT and increase
the FRONT index.
5. Before enqueing, we check if queue is already full.
6. Before dequeuing, we check if queue is already empty.
7. When enqueing the first element, we set the value of FRONT to 1.
8. When dequeing the last element, we reset the values of FRONT and REAR to 0.

16

30
Representation of Queue (or) Implementation of Queue:
The queue can be represented in two ways:
1. Queue using Array
2. Queue using Linked List
1.Queue using Array:
Let us consider a queue, which can hold maximum of five elements. Initially the queue is
empty.

Now, insert 11 to the queue. Then queue status will be:

Next, insert 22 to the queue. Then the queue status is:

Again insert another element 33 to the queue. The status of the queue is:

Now, delete an element. The element deleted is the element at the front of the queue.So
the status of the queue is:

Again, delete an element. The element to be deleted is always pointed to by the FRONT
pointer. So, 22 is deleted. The queue status is as follows:

Now, insert new elements 44 and 55 into the queue. The queue status is:

17

31
Next insert another element, say 66 to the queue. We cannot insert 66 to the queue as the
rear crossed the maximum size of the queue (i.e., 5). There will be queue full signal. The
queue status is as follows:

Now it is not possible to insert an element 66 even though there are two vacant positions in
the linear queue. To overcome this problem the elements of the queue are to be shifted
towards the beginning of the queue so that it creates vacant position at the rear end. Then
the FRONT and REAR are to be adjusted properly. The element 66 can be inserted at the
rear end. After this operation, the queue status is as follows:

This difficulty can overcome if we treat queue position with index 0 as a position that comes
after position with index 4 i.e., we treat the queue as a circular queue.

Queue operations using array:

a.enqueue() or insertion():which inserts an element at the end of the queue.
void insertion() Algorithm: Procedure for insertion():
{ Step-1:START
if(rear==max) Step-2: if rear==max then
printf("\n Queue is Full"); Write ‘Queue is full’
else Step-3: otherwise
{ 3.1: read element ‘queue[rear]’
printf("\n Enter no %d:",j++); Step-4:STOP
scanf("%d",&queue[rear++]);
}
}

b.dequeue() or deletion(): which deletes an element at the start of the queue.

void deletion() Algorithm: procedure for deletion():
{ Step-1:START
if(front==rear) Step-2: if front==rear then
{ Write’ Queue is empty’
printf("\n Queue is empty"); Step-3: otherwise
} 3.1: print deleted element
else Step-4:STOP
{
printf("\n Deleted Element is
%d",queue[front++]);
x++;
}}

18

32
c.dispaly(): which displays an elements in the queue.
void deletion() Algorithm: procedure for deletion():
{ Step-1:START
if(front==rear) Step-2: if front==rear then
{ Write’ Queue is empty’
printf("\n Queue is empty"); Step-3: otherwise
} 3.1: for i=front to rear then
else 3.2: print ‘queue[i]’
{ Step-4:STOP
for(i=front; i<rear; i++)
{
printf("%d",queue[i]);
printf("\n");
}
}
}

2. Queue using Linked list:

We can represent a queue as a linked list. In a queue data is deleted from the front end and
inserted at the rear end. We can perform similar operations on the two ends of alist. We use
two pointers front and rear for our linked queue implementation.
The linked queue looks as shown in figure:

Applications of Queue:
1. It is used to schedule the jobs to be processed by the CPU.
2. When multiple users send print jobs to a printer, each printing job is kept in the printing
queue. Then the printer prints those jobs according to first in first out (FIFO) basis.
3. Breadth first search uses a queue data structure to find an element from a graph.

19

33
 CIRCULAR QUEUE
A more efficient queue representation is obtained by regarding the array Q[MAX] as
circular. Any number of items could be placed on the queue. This implementation of a
queue is called a circular queue because it uses its storage array as if it were a circle instead
of a linear list.
There are two problems associated with linear queue. They are:

 Time consuming: linear time to be spent in shifting the elements to the beginning of
the queue.
 Signaling queue full: even if the queue is having vacant position.
For example, let us consider a linear queue status as follows:

Next insert another element, say 66 to the queue. We cannot insert 66 to the queue as the
rear crossed the maximum size of the queue (i.e., 5). There will be queue full signal. The
queue status is as follows:

This difficulty can be overcome if we treat queue position with index zero as a position that
comes after position with index four then we treat the queue as a circular queue.
In circular queue if we reach the end for inserting elements to it, it is possible to insert new
elements if the slots at the beginning of the circular queue are empty.
Representation of Circular Queue:
Let us consider a circular queue, which can hold maximum (MAX) of six elements. Initially
the queue is empty.

Now, insert 11 to the circular queue. Then circular queue status will be:

20

34
Insert new elements 22, 33, 44 and 55 into the circular queue. The circular queue status is:

Now, delete an element. The element deleted is the element at the front of the circular
queue. So, 11 is deleted. The circular queue status is as follows:

Again, delete an element. The element to be deleted is always pointed to by the FRONT
pointer. So, 22 is deleted. The circular queue status is as follows:

Again, insert another element 66 to the circular queue. The status of the circular queue is:

21

35
Now, insert new elements 77 and 88 into the circular queue. The circular queue status is:

Now, if we insert an element to the circular queue, as COUNT = MAX we cannot add the
element to circular queue. So, the circular queue is full.

Operations on Circular queue:

a.enqueue() or insertion():This function is used to insert an element into the circular queue.
In a circular queue, the new element is always inserted at Rear position.

void insertCQ() Algorithm: procedure of insertCQ():

{
int data; Step-1:START
if(count ==MAX) Step-2: if count==MAX then
{ Write “Circular queue is full”
printf("\n Circular Queue is Full"); Step-3:otherwise
} 3.1: read the data element
else 3.2: CQ[rear]=data
{ 3.3: rear=(rear+1)%MAX
printf("\n Enter data: "); 3.4: count=count+1
scanf("%d", &data); Step-4:STOP
CQ[rear] = data;
rear = (rear + 1) % MAX;
count ++;
printf("\n Data Inserted in the Circular
Queue ");
}
}

22

36
b.dequeue() or deletion():This function is used to delete an element from the circular
queue. In a circular queue, the element is always deleted from front position.
void deleteCQ() Algorithm: procedure of deleteCQ():
{
if(count ==0) Step-1:START
{ Step-2: if count==0 then
printf("\n\nCircular Queue is Empty.."); Write “Circular queue is empty”
} Step-3:otherwise
else 3.1: print the deleted element
{ 3.2: front=(front+1)%MAX
printf("\n Deleted element from Circular 3.3: count=count-1
Queue is %d ", CQ[front]); Step-4:STOP
front = (front + 1) % MAX;
count --;
}
}

c.dispaly():This function is used to display the list of elements in the circular queue.
void displayCQ() Algorithm: procedure of displayCQ():
{
int i, j; Step-1:START
if(count ==0) Step-2: if count==0 then
{ Write “Circular queue is empty”
printf("\n\n\t Circular Queue is Empty "); Step-3:otherwise
} 3.1: print the list of elements
else 3.2: for i=front to j!=0
{ 3.3: print CQ[i]
printf("\n Elements in Circular Queue are: 3.4: i=(i+1)%MAX
"); Step-4:STOP
j = count;
for(i = front; j != 0; j--)
{
printf("%d\t", CQ[i]);
i = (i + 1) % MAX;
}
}
}

Deque:
In the preceding section we saw that a queue in which we insert items at one end and from
which we remove items at the other end. In this section we examine an extension of the
queue, which provides a means to insert and remove items at both ends of the queue. This
data structure is a deque. The word deque is an acronym derived from double-ended queue.
Below figure shows the representation of a deque.

23

37
deque provides four operations. Below Figure shows the basic operations on a deque.
• enqueue_front: insert an element at front.
• dequeue_front: delete an element at front.
• enqueue_rear: insert element at rear.
• dequeue_rear: delete element at rear.

There are two variations of deque. They are:

• Input restricted deque (IRD)
• Output restricted deque (ORD)
An Input restricted deque is a deque, which allows insertions at one end but allows
deletions at both ends of the list.
An output restricted deque is a deque, which allows deletions at one end but allows
insertions at both ends of the list.
Priority Queue:
A priority queue is a collection of elements such that each element has been assigned a
priority. We can insert an element in priority queue at the rare position. We can delete an
element from the priority queue based on the elements priority and such that the order in
which elements are deleted and processed comes from the following rules:

1. An element of higher priority is processed before any element of lower priority.

2. Two elements with same priority are processed according to the order in which they were
added to the queue. It follows FIFO or FCFS(First Comes First serve) rules.

24

38
We always remove an element with the highest priority, which is given by the minimal
integer priority assigned.

A prototype of a priority queue is time sharing system: programs of high priority are
processed first, and programs with the same priority form a standard queue. An efficient
implementation for the Priority Queue is to use heap, which in turn can be used for sorting
purpose called heap sort

Priority queues are two types:

1. Ascending order priority queue
2. Descending order priority queue
1. Ascending order priority queue: It is Lower priority number to high priority number.
Examples: order is 1,2,3,4,5,6,7,8,9,10
2. Descending order priority queue: It is high priority number to lowest priority number.
Examples: Order is 10,9,8,7,6,5,4,3,2,1
Implementation of Priority Queue:
Implementation of priority queues are two types:
1. Through Queue(Using Array)
2. Through Sorted List(Using Linked List)
1. Through Queue (Using Array): In this case element is simply added at the rear end as
usual. For deletion, the element with highest priority is searched and then deleted.

2. Through sorted List (Using Linked List): In this case insertion is costly because the
element insert at the proper place in the list based on the priority. Here deletion is easy
since the element with highest priority will always be in the beginning of the list.

25

39
1. Difference between stacks and Queues?
stacks Queues
1.A stack is a linear list of elements in which 1.A Queue is a linerar list of elements in which
the element may be inserted or deleted at the elements are added at one end and
one end. deletes the elements at another end.
2. . In Queue the element which is inserted
2. In stacks, elements which are inserted first is the element deleted first.
last is the first element to be deleted.
3. Queues are called FIFO (First In First
3.Stacks are called LIFO (Last In First Out)list.
Out)list
4. In Queue elements are removed in the
4.In stack elements are removed in reverse same order in which thy are inserted.
order in which thy are inserted.
5. Suppose the elements a,b,c,d,e are inserted
5.suppose the elements a,b,c,d,e are in the Queue, the deletion of elements will be
inserted in the stack, the deletion of in the same order in which thy are inserted.
elements will be e,d,c,b,a.
6. In Queue there are two pointers one for
6.In stack there is only one pointer to insert insertion called “Rear” and another for
and delete called “Top”. deletion called “Front”.

7.Initially top=-1 indicates a stack is empty. 7. Initially Rear=Front=-1 indicates a Queue is

empty.
8.Stack is full represented by the condition
TOP=MAX-1(if array index starts from ‘0’). 8.Queue is full represented by the condition
Rear=Max-1.
9.To push an element into a stack, Top is
incremented by one 9.To insert an element into Queue, Rear is
incremented by one.
10.To POP an element from stack,top is
decremented by one. 10.To delete an element from Queue, Front is

26

40
 incremented by one.
11.The conceptual view of Stack is as
follows: 11.The conceptual view of Queue is as
follows:

27

41