Data Structure
Safia Sadruddin
Course Outcomes
1. Differentiate between linear and non-linear data structures and apply basic
operations such as searching, insertion, deletion, and traversal on stacks and
queues. (BL3)
2. Perform various operations like searching, insertion, deletion and traversals
on Linked List. (BL3)
3. Apply tree data structure to solve hierarchical and real-world problems.
(BL4)
4. Utilize the graph data structure to solve problems in various domains. (BL3)
5. Select and apply suitable searching techniques to solve computational
problems. (BL4)
Reema Thareja, “Data Structures E. Balagurusamy, “Data
using C”, Oxford Press. Structure Using C”, Tata
McGraw-Hill Education India.
Chapter-01
Introduction, Stacks & Queues
Outline
● Introduction to Data Structure
● Concept of ADT, Classification of Data Structure
● Array Revision, Recursion
● Stacks:
● ADT Representation, Operations on Stack
● Applications of Stack, Infix to Postfix Conversion
● Expression Evaluation, balanced parenthesis
● Queues:
● ADT Representations, Operations on Queue
● Circular Queue, Priority Queue, Double Ended Queue
● Applications of Queue
Why Data Structures?
Data Structure is a particular way of storing and organizing information in a computer so that it can
be retrieved and used most productively.
● Each Data Structure allows data to be stored in a specific manner.
● Data Structure allows efficient data search and retrieval.
● Specific Data Structures are decided to work for specific problems.
● It allows to manage large amount of data such as large databases and indexing services such as
hash table.
ADT (Abstract Data Type)
Abstract data type are like user defined data type on which we can
perform functions without knowing what is there inside the datatype
and how the operations are performed on them.
• An ADT is composed of
• A collection of Data
• A set of operations on that data
• Specification of an ADT indicate
• What the ADT operations do, not how to implement them
• Implementation of an ADT
• Includes choosing a particular data structure
Data Structutre (Definition)
In computer science, a data structure is a data
organization, management, and storage format that
enables efficient access and modifications.
Linear Data Structure:
•A data structure is said to be linear if its
elements form a sequence or a linear
list.
Example: array, stack, queue, linklist
Non-Linear Data Structure:
Non-linear data structure does not
arrange the data consecutively rather it is
arranged in sorted order.
Example: tree, graph
Static and Dynamic Data
Structures
• In Static data structure the size of the structures is
fixed.
• The content of the data structure can be modified but
without changing the memory space allocated to it.
• In Dynamic data structure the size of the structures
is not fixed and can be modified during the operations
performed on it.
• Dynamic data structures are designed to facilitate
change of data structures in the run time.
Operations on Data
Structures
Various operations on Data Structure are–
Operations on Data
Structures
1. Traversing: Every data structure contains the set of data elements. Traversing
the data structure means visiting each element of the data structure in order to
perform some specific operation like searching or sorting. Example: If we need to
calculate the average of the marks obtained by a student in 6 different subject, we need to traverse
the complete array of marks and calculate the total sum, then we will divide that sum by the number
of subjects i.e. 6, in order to find the average.
2. Insertion: Insertion can be defined as the process of adding the elements to
the data structure at any location. If the size of data structure is n then we can
only insert n-1 data elements into it.
3. Deletion: The process of removing an element from the data structure is
called Deletion. We can delete an element from the data structure at any
random location. If we try to delete an element from an empty data structure
then underflow occurs.
Operations on Data
Structures
1. Searching: The process of finding the location of an element within the data
structure is called Searching. There are two algorithms to perform searching,
Linear Search and Binary Search. We will discuss each one of them later in
this tutorial.
2. Sorting: The process of arranging the data structure in a specific order is
known as Sorting. There are many algorithms that can be used to perform
sorting, for example, insertion sort, selection sort, bubble sort, etc.
3. Merging: When two lists List A and List B of size M and N respectively, of
similar type of elements, clubbed or joined to produce the third list, List C of
size (M+N), then this process is called merging
Difference between Static Arrays and
Dynamic Arrays
Types of Arrays:
Static Array: In this type of array, memory is allocated at compile time having a fixed size of it.
We cannot alter or update the size of this array.
Dynamic Array: In this type of array, memory is allocated at run time but not having a fixed
size. Suppose, a user wants to declare any random size of an array, then we will not use
a static array, instead of that a dynamic array is used in hand. It is used to specify the size of it
during the run time of any program.
Operations on Data Structures
An array in C is a fixed-size collection of similar data items stored in
contiguous memory locations. It can be used to store the collection of
primitive data types such as int, char, float, etc., as well as derived and user-
defined data types such as pointers, structures, etc.
Array Declaration
data_type array_name[size];
int arr[5];
Array Initialization
//Partial Initialisation
int arr[5] = {2, 4, 8};
//Skiping the size of the array.
int arr[] = {2, 4, 8, 12, 16};
Dynamic Array Using malloc() Function
The “malloc” or “memory allocation” method in C is used
to dynamically allocate a single large block of memory with
the specified size.
ptr = (cast-type*) malloc(byte-size);
ptr = (int*) malloc(100 * sizeof(int));
Dynamic Array Using calloc() Function
The “calloc” or “contiguous allocation” method in C is used to dynamically
allocate the specified number of blocks of memory of the specified type and
initialized each block with a default value of 0.
ptr = (cast-type*)calloc(n, element-
size);
ptr = (int*) calloc(5, sizeof(float));
Key Difference between Static and Dynamic
Arrays:
What is recursion?
The process in which a function calls itself directly or
indirectly is called recursion and the corresponding
function is called as recursive function.
Recursion is a technique that solves a problem by
solving a smaller problem of the same type.
Examples: factorial, Fibonacci, Towers of Hanoi, Tree
Traversal, BFS and DFS etc.
Coding the factorial function
Recursive implementation
int Factorial(int n)
{
if (n==0) // base case
return 1;
else
return n * Factorial(n-1);
}
Implementation of Recursion
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.
Recursion vs. iteration
Iteration can be used in place of recursion
An iterative algorithm uses a looping construct
A recursive algorithm uses a branching structure
Recursive solutions are often less efficient, in
terms of both time and space, than iterative
solutions
Recursion can simplify the solution of a
problem, often resulting in shorter, more easily
understood source code
Three-Question Verification
1. Method
The Base-Case Question:
Is there a non-recursive way out of the function, and
does the routine work correctly for this "base" case?
2.The Smaller-Caller Question:
Does each recursive call to the function involve a
smaller case of the original problem, leading
inescapably to the base case?
3. The General-Case Question:
Assuming that the recursive call(s) work correctly, does
the whole function work correctly?
Stack
Stack
A stack is a data structure that stores data in such a
way that the last piece of data stored, is the first one
retrieved
● also called Last-In, First-Out (LIFO)
● Only access to the stack is the top element
● consider trays in a cafeteria
to get the bottom tray out, you must first
remove all of the elements above
Stack ADT
Stack ADT
There are some common operations that are
performed on the stack which are as follows :
• push() : Inserting element at top of the stack.
• pop() : Deleting element from the top of the stack.
• isEmpty() : Checking whether stack is empty or not.
• isFull() : Checking whether stack is full or not.
• peek() : Gives top element of the stack.
• count() : Gives number of elements in the stack.
• display(): Displays the content of stack.
Stack Operations
PUSH: THE
OPERATION TO
PLACE A NEW ITEM
AT THE TOP OF THE
STACK
Stack Operations
POP: THE OPERATION
TO REMOVE THE NEXT
ITEM FROM THE TOP
OF THE STACK
Stack Operations
STACKTOP: THE OPERATION
RETURNS THE TOP MOST ELEMENT
OF THE STACK
● ALSO KNOWN AS PEEK
OPERATION
Algorithm
isEmpty Operation
• THE EMPTY OPERATION CHECKS THE STATUS OF THE STACK.
• THIS OPERATION RETURNS TRUE IF THE STACK IS EMPTY AND
FALSE IF THE STACK IS NOT EMPTY.
If TOP==-1, then
True
Else
False
TOP =-1
Stack underflow condition 46
The condition resulting from trying to pop an empty stack.
TOP =-1
47
isFull Operation
The full operation checks the status of the stack.
This operation returns true if the stack is full and false if the stack is not
full.
Consider Max= 5
If TOP==Max-1, then
TOP 50 Max-1
True
Else
40
False
30
20
10
0
Stack overflow condition 48
The condition resulting from trying to push an element onto a full stack.
Consider Max= 5
TOP 50 Max-1
40
30
20
10
0
Algorithm for Push Operation 49
Step I: IF TOP=MAX-1, then PRINT
“OVERFLOW” TO
P
[END OF IF] T
50
TO O
Step 2: SET TOP=TOP+1 P P 40
TO 40
Step 3: SET STACK[TOP]=VALUE TO
P
30 30 30
P 20
Step 4: END 20 20 20
10 10 10 10 10
Stack Empty Stack Full
TOP = -1
50
Algorithm for Pop Operation
TOP
Step I: IF TOP = NULL , then PRINT
“UNDERFLOW”
TOP
50
[END OF IF] TOP
40
Step 2: SET VALUE = STACK[TOP] 40 TOP
30 30 30
Step 3: SET TOP=TOP-1 TOP
20 20 20 20
Step 4: END
10 10 10 10 10
51
Algorithm for Peek Operation
Returns the value of the top most element of the stack without
deleting that element from the stack
Step I: IF TOP = NULL , then
PRINT “STACK IS EMPTY” 50
40
[END OF IF] 40
30 30 30
Step 2: RETURN STACK[TOP]
20 20 20 20
Step 3: END 10 10 10 10 10
Applications of Stack 52
Expression Conversion
Expression Evaluation
Reverse a string
Parsing of Well formed parenthesis
Decimal to binary conversion
Recursive procedure call
Applications of
Stacks
Algebraic Expression
An algebraic expression is a legal combination of operands
and the operators.
Operand is the quantity (unit of data) on which a
mathematical operation is performed.
Operand may be a variable like x, y, z or a constant like 5,
4,0,9,1 etc.
Operator is a symbol which signifies a mathematical or
logical operation between the operands.
Example of familiar operators include +,-,*, /, ^
Considering these definitions of operands and operators
now we can write an example of expression as x+y*z.
Algebraic Expression 55
One of the compiler’s task is to evaluate algebraic expression.
Example of assignment statement:
y=x+z*(w/x+z*(7+6))
Compiler must determine whether the right side expression is
syntactically legal algebraic expression before evaluating the
expression.
Infix, Postfix and Prefix
Expressions
INFIX: From our schools times we have been familiar with the
expressions in which operands surround the operator, e.g.
x+y, 6*3 etc this way of writing the Expressions is called
infix notation.
POSTFIX: Postfix notation are also Known as Reverse
Polish Notation (RPN). They are different from the infix
and prefix notations in the sense that in the postfix notation,
operator comes after the operands, e.g. xy+, xyz+* etc.
PREFIX: Prefix notation also Known as Polish notation.In
the prefix notation, as the name only suggests, operator
• Prefix: + a b
• Infix: a + b (what we use in grammar school)
• Postfix: a b +
• The terms infix, prefix, and postfix tell us whether
the operators go between, before, or after the
operands.
Operator Priorities
This is done by assigning operator priorities.
– priority(*) = priority(/) > priority(+) =
priority(-)
Parentheses
• Evaluate 2+3*5.
• + First:
(2+3)*5 = 5*5 = 25
• * First:
2+(3*5) = 2+15 = 17
• Infix notation requires Parentheses.
Postfix Notation
• 235*+=
=235*+
= 2 15 + = 17
• 23+5*=
=23+5*
= 5 5 * = 25
• No parentheses needed here either!
Examples of infix to prefix and postfix
Infix PostFix Prefix
A+B AB+ +AB
(A+B) * (C + D) AB+CD+* *+AB+CD
A-B/(C*D^E) ABCDE^*/- -A/B*C^DE
Conversion Of An Infix Expression to Postfix Expression
• Step 1: Scan all the symbols one by one from left to right in the
given Infix Expression.
• IF the symbol is an operand (whether a digit or an alphabet) is
encountered, add it to the postfix expression.
• IF a “(“ is encountered, push it on the stack
• IF a “)” is encountered, then;
• Repeatedly pop from stack and add it to the postfix expression
until a “(” is encountered.
• Discard the “(“. That is, remove the “(“ from stack and do not
add it to the postfix expression.
• IF an operator O is encountered, then;
• Repeatedly pop from stack and add each operator (popped from
the stack) to the postfix expression until it has the same
precedence or a higher precedence than O
• Else Push the operator O to the stack
• Step 2: Repeatedly pop from the stack and add it to the postfix
expression until the stack is empty
• Step 3: EXIT
Infix to Postfix Conversion 63
Stack
Infix Expression
A+B*C–D/E
Postfix Expression
Infix to Postfix Conversion 64
Stack
Infix Expression
+B*C–D/E
Postfix Expression
A
Infix to Postfix Conversion 65
Stack
Infix Expression
B*C–D/E
Postfix Expression
+
Infix to Postfix Conversion 66
Stack
Infix Expression
*C–D/E
Postfix Expression
AB
+
Infix to Postfix Conversion 67
Stack
Infix Expression
C–D/E
Postfix Expression
AB
+
Infix to Postfix Conversion 68
Stack
Infix Expression
–D/E
Postfix Expression
ABC
+
Infix to Postfix Conversion 69
Stack
Infix Expression
–D/E
Postfix Expression
ABC*
+
Infix to Postfix Conversion 70
Stack
Infix Expression
–D/E
Postfix Expression
ABC*+
Infix to Postfix Conversion 71
Stack
Infix Expression
D/E
Postfix Expression
ABC*+
–
Infix to Postfix Conversion 72
Stack
Infix Expression
/E
Postfix Expression
ABC*+D
–
Infix to Postfix Conversion 73
Stack
Infix Expression
Postfix Expression
ABC*+D
–
Infix to Postfix Conversion 74
Stack
Infix Expression
Postfix Expression
ABC*+ DE
–
Infix to Postfix Conversion 75
Stack
Infix Expression
Postfix Expression
ABC*+ DE/
–
Infix to Postfix Conversion 76
Stack
Infix Expression
Postfix Expression
ABC*+ DE/ -
Infix to Postfix Conversion
Convert A+B*C to a postfix expression
Infix Stack Postfix
A+B*C empty -
+B*C empty A
B*C + A
*C + AB
C +* AB
finish +* ABC
empty ABC*+
Infix to Postfix Conversion
Convert A*B+C to a postfix expression
Infix Stack Postfix
A*B+C empty -
*B+C empty A
B+C * A
+C * AB
C + AB*
finish + AB*C
empty AB*C+
Infix to Postfix Example
A + B * C - D / E
Infix Stack
Postfix
a) A + B * C - D / E empty
b) + B * C - D / E empty
A
c) B * C - D / E +
A
d) * C - D / E +
A B
e) C - D / E + *
A B
f) - D / E + *
A B C
g) D / E -
A B C *+
h) / E -
Infix to Postfix Example
A * B - ( C + D ) + E
Infix Stack
Postfix
a) A * B - ( C - D ) + E empty
empty
b) * B - ( C + D ) + E empty
A
c) B - ( C + D ) + E *
A
d) - ( C + D ) + E *
A B
e) - ( C + D ) + E empty
A B *
f) ( C + D ) + E -
A B *
g) C + D ) + E - (
A B *
h) + D ) + E - (
A B * C
i) D ) + E - ( +
Infix to Postfix Example
A - (B / C + (D % E * F ) / G)*H
Exercise: Convert the following infix expression into postfix expression
A – ( B / C + (D % E * F) / G )* H
Infix Stack
Postfix
A empty
- -
( -(
B -(
AB
/ -(/
AB
C -(/
ABC
+ -(+
ABC/
( -(+(
ABC/
D -(+(
ABC/D
convert 2*3/(2-1)+5*3 into Postfix form
Infix Stack
Postfix
2 empty
2
* *
2
3 *
23
/ /
23*
( /(
23*
2 /(
Examples
Convert the following infix expression into postfix form:
((A – (B + C)) * D) ^ (E + F)
((a+b)*(c/d)+e)
A+B*(C^D-E)
A+B *C/D-F +A^E
a * b / (c – a) + d * e
Problem Solving
You are given the following sequence of uppercase letters and asterisks (*)
D A T A*S*T*R*U*C*T**U*R*E*S***
Assume each letter corresponds to a push() operation that pushes
that letter onto a stack, and each asterisk * corresponds to a pop()
operation that removes the top element from the stack and outputs it.
❓ Question:
Simulate the stack operations and show the sequence of values returned by the
pop operations.
•What is the final content of the stack after all operations?
•How many push and pop operations were performed?
•Was the stack ever empty during the operations?
Program to convert infix to postfix
#include <stdio.h> int main() {
#include <stdlib.h> printf("Enter the infix expression:");
#include <string.h> fgets(infix,MAX,stdin);
#define MAX 30
// Function call
char stack[MAX]; infixToPostfix();
char infix[MAX],postfix[MAX]; print();
int top=-1; return 0;
}
Program to convert infix to postfix
void infixToPostfix() { case '+':
int i,j=0; case '-':
char next; case '*':
char symbol; case '/':
case '^':
for (int i = 0; i < strlen(infix); i++) { while(!isEmpty() && prece(stack[top])
symbol=infix[i]; >=prece(symbol))
switch(symbol) postfix[j++]=pop();
{ push(symbol);
case '(': break;
push(symbol); default:
break; postfix[j++] = symbol;
}
case ')': }
while((next=pop())!='(')
postfix[j++]=next; while(!isEmpty())
break; postfix[j++]=pop();
postfix[j]='\0’;
}
Program to convert infix to postfix
int prece(char symbol)
{
switch(symbol)
{
case '^':
return 3;
case '/':
case '*':
return 2;
case '+':
case '-':
return 1;
default:
return 0;
}
}
Evaluate the postfix expression
Step 1: Scan every character of the postfix expression
and repeat steps 2 and 3 until all characters are
scanned
Step 2: IF an operand is encountered, push it on the
stack
IF an operator O is encountered, then
• pop the top two elements from the stack as A
and B
• Evaluate B O A, where A was the topmost element
and B was the element below A.
• Push the result of evaluation on the stack
Step 3: SET RESULT equal to the topmost element of the
stack
Step 4: EXIT
Postfix Evaluation
Operand: push
Operator: pop 2 operands, do the math, pop result
back onto stack
1 2 3 + *
Postfix Stack( bot -> top )
a) 1 2 3 + *
b) 2 3 + * 1
c) 3 + * 1 2
d) + * 1 2 3
e) * 1 5 // 5 from 2 + 3
f) 5 // 5 from
1 * 5
Consider the infix expression given as “9 - (( 3 * 4) +
8) / 4”. Evaluate the expression.
The infix expression "9 - (( 3 * 4) + 8) / 4" can
be written as “9 3 4 * 8 + 4 / -“ using postfix
notation.
Character scanned Stack
9 9
3 9, 3
4 9, 3, 4
* 9, 12
8 9, 12, 8
+ 9, 20
4 9, 20, 4
/ 9, 5
- 4
Consider the infix expression given as “ 4 5 + 7 2
- * ” . Evaluate the expression.
Question : Evaluate the following
expression in postfix :
6 2 3+-3 8 2/+*2^3+
Well form-ness of Parenthesis 96
(Parenthesis Balance)
Examples of balanced parenthesis.
(a+b), (a/b+c), a/((b-c)*d)
Open and closed parenthesis are
properly paired.
Examples of not balance parenthesis.
((a+b)*2 and m*(n+(k/2)))
Open and closed parenthesis are not
Check Balanced Parentheses in
an Expression
1. Traverse an input string and pick each character at
a time.
2. If the current character is starting bracket ‘{‘, ‘(‘,
‘[‘ then push it in a stack.
3. If the current character is closing bracket ‘}’, ‘)’, ‘]’
and the top of the stack is starting bracket then
pop from the stack.
4. After complete traversal, if the stack is empty then
it is balanced parentheses otherwise it is not
balanced.
Example
Example of Balance Parenthesis : 99
Use of Stack
Every ( is Insert into stack Pop ( when found )
3 3 3 3
2 2 2 2
1 1 ( 1 1
0 ( 0 ( 0 ( 0
Push(() Push(() Pop() Pop()
Expression a(b(c)) have balance parenthesis since when end of
string is found the stack is empty.
Example
Given an input expression [()]{}{[()()]()}.Check for balanced
parentheses in the expression (well-formedness) using Stack.
Expression stack
[()]{}{[()()]()} [
()]{}{[()()]()} [(
)]{}{[()()]()} [
]{}{[()()]()}
empty
{}{[()()]()} {
}{[()()]()}
empty
{[()()]()} {
[()()]()}
{[
()()]()}
{[(
)()]()}
{[
()]()}
{[(
)]()}
{[
Postfix Evaluation
#include<stdio.h>
#define MAX 100
float stack[MAX];
int top=-1;
int main()
{
int value;
char exp[100];
printf("\n Enter any postfix expression:");
fgets(exp,MAX,stdin);
value=evaluatePostfixExp(exp);
printf("\n Value of the postfix expression = %d ", value);
return 0;
}
Postfix Evaluation
int postfix_evaluate(char expression[]) { push(result);
int i = 0; }
char symbol = expression[i]; i++;
int operand1, operand2, result; symbol = expression[i];
}
while (symbol != '\0') { result = pop();
if (symbol >= '0' && symbol <= '9') { return result;
int num = symbol - '0'; }
push(num);
}
else if (is_operator(symbol)) {
operand2 = pop();
operand1 = pop();
switch(symbol) {
case '+': result = operand1 + operan
d2; break;
case '-': result = operand1 - operand2
; break;
case '*': result = operand1 * operand2
Postfix Evaluation
int is_operator(char symbol) {
if (symbol == '+' || symbol == '-' || symbol == '*' || symbol
== '/') {
return 1;
}
return 0;
}
Stack Applications
• Converting Decimal to Binary: Consider the following pseudocode
1) Read (number)
2) Loop (number > 0)
1) digit = number modulo 2
2) print (digit)
3) number = number / 2
// from Data Structures by Gilbert and Forouzan
The problem with this code is that it will print the binary
number backwards. (ex: 19 becomes 11001000 instead of 00010011. )
To remedy this problem, instead of printing the digit right away, we can
push it onto the stack. Then after the number is done being converted, we
pop the digit out of the stack and print it.
Stack Applications
• Reversing Data: We can use stacks to reverse data.
(example: files, strings)
Very useful for finding palindromes.
Consider the following pseudocode:
1) read (data)
2) loop (data not EOF and stack not full)
1) push (data)
2) read (data)
3) Loop (while stack notEmpty)
1) pop (data)
2) print (data)
Practice infix to postfix conversion:
https://ds1-iiith.vlabs.ac.in/exp/infix-postfix/infix%20to-postfix-conversion-wi
th-stack/infix_to_postfix.html
Practice postfix evaluation:
https://ds1-iiith.vlabs.ac.in/exp/infix-postfix/evaluation-of-postfix-expression
s/postfix_eval.html
stack using arrays:
https://ds1-iiith.vlabs.ac.in/exp/stacks-queues/stacks/stackarrays.html
