Data Structures

Dr. Pandu Sowkuntla

Asst. Professor,
Department of CSE

Data Structures--> Unit-I Pandu Sowkuntla 1

 INTRODUCTION
TO
UNIT-I DATA STRUCTURES
2
Data Structures--> Unit-I: Introduction to Data Structures Pandu Sowkuntla
 Outline ► Why Data Structures?
of 1. Introduction to ► What is Data Structure?
Unit-I Data Structures ► Types of Data Structures

► Why ADT?
Data 2. Abstract Data Types (ADT) ► What is ADT?
Structures ► ADT implementation

► What is an Algorithm?
Unit-I 3. Algorithm Efficiency ► Pseudocode? ▪ Big-O notation
► Complexity Analysis ▪ Time Complexity
Unit-II ▪ Space Complexity
► Sparse matrix representation &
Unit-III implementation
4. Applications of Array ADT
► Polynomial Expressions representation &
Unit-IV implementation

Unit-V ► Stack representation ▪ Infix, prefix,

5. Stack ADT ► Array implementation of Stacks postfix Conversions
► Applications of Stacks ▪ Evaluation of
Postfix and Prefix
► Queue representation
expressions
6. Queue ADT ► Array implementation of Queues
► Circular Queues
► Applications of Queues 3
Data Structures--> Unit-I: Pandu Sowkuntla
 Why Data Structures?

What is a variable?

a
int a;
2 Bytes

b
float b;
4 Bytes

c
char c;
1 Byte

A variable is a name of the memory

location.

Data Structures--> Unit-I: Introduction to Data Structures 4

Pandu Sowkuntla
 Why Data Structures?

o What is an Array?

int a ……………….
a[10];
index 0 1 2 8 9

Array is a data structure used to store homogeneous elements at consecutive memory locations.

1. Is it posible to store element at the location of a[9] (at the end)? YES

2. Is it posible to insert the elements at the middle or at the begining locations NO

of the array?

3. Is it posible to store the elements into the array beyond the size of the array? NO

If array is stored as Linked List

5
Data Structures--> Unit-I: Introduction to Data Structures Pandu Sowkuntla
10 Students data 10 Students data 10 Students data 10 Students data

Name: Name: Name: Name:

Roll no: Roll no: Roll no: Roll no:
……………..
Mobile no: Mobile no: Mobile no: Mobile no:
Marks Marks Marks Marks

Faculty data Faculty data

………………..
Name: Name:
EMP ID: EMP ID:
Mobile no: Mobile no:
Dept: Faculty Dept:
Coordinator data
Name:
EMP ID:
Mobile no:
Dept:

Data Structures--> Unit-I: Introduction to Data Structures Pandu Sowkuntla 6

 Why Data Structures?

► To store, process and retrieve the large amounts of complex data efficiently.

► To design efficient algorithms (programs).

► Programmers can save time and memory space in storing, accessing and processing large
amounts of data.

✓ Efficiency

✓ Reusability

✓ Abstraction

7
Data Structures--> Unit-I: Introduction to Data Structures Pandu Sowkuntla
 What is Data Structure?

► A data structure is an aggregation of atomic and composite data into a set with the
defined relationships.
OR
► A data structure is a particular way of organizing data in a computer so that it can be
used effectively.

Ex: int, float, char…etc.

8
Data Structures--> Unit-I: Introduction to Data Structures Pandu Sowkuntla
 Abstract Data Types
o What is Data? ► Composite Data
The data that can be divided (not an atomic
Collections of facts from which data)
conclusions may be drawn is known as +91 9231093219 Date: dd/mm/yyyy
data.
Country code
Mobile no
o What is Information?

Data from which decisions can be made

is known as information. What is a Data Type?

► Atomic Data

The data that consists of single piece of

information.

int a=2314;
(Data can not be divided further)

A Data Type consists of two parts: a set of data, and

the operations that can be performed on the data.

9
Data Structures--> Unit-I: Introduction to Data Structures Pandu Sowkuntla
 Abstract Data Types

We got answers for following questions

What is Data? What is Data Type? What is Data Structure?

Why Abstract Data Types?

1. Can I retrieve the elements from the array in last in first out (LIFO) or first in last out
manner?

2. Can I retrieve the first stored element first (first in first out (FIFO)) manner?

3. Can I store the data of DATE in the format dd/mm/yyyy?

• Can I do addition, subtraction operations on date data
• Can I add some days?
• Can I find the day for the specified date?

➢ Can a programmer create his own data types (user defined data types) for solving above type
of problems?

10
Data Structures--> Unit-I: Abstract Data Types Pandu Sowkuntla
 Abstract Data Types

An abstract data type is a data declaration packaged together with the operations that are
meaningful for the data type.

➢ The concept Abstraction means:

• We know what a data type can do

• How it is done is hidden

(i.e., implementation details are
hidden)

➢ Programmer encapsulates the data

and operations on the data and
hides the implementation details.

There are two basic structures we can

use to implement an ADT:
1. Array implementations
Abstract Data Type Model 2. Linked list implementations
11
Data Structures--> Unit-I: Abstract Data Types Pandu Sowkuntla
 Algorithm Efficiency

12
Data Structures--> Unit-I: Algorithm Efficiency Pandu Sowkuntla
 Algorithm
► Why Algorithm?
• Provides a design to solve a problem.
al-Khwarizmi
• Improves the efficiency in problem solving.
9th-century’s Arab scholar
• To utilize the resources efficiently in problem solving.

► What is an Algorithm?
An algorithm is finite set of well-defined instructions,
if followed, accomplishes a particular task.
Input Algorithm Output
An Algorithm must satisfy the following criteria.

• Input: Zero or more quantities which are externally supplied.

• Output: At least one quantity is generated.

• Finiteness: Execution terminates after a finite number of steps for all possible inputs.

• Definiteness: Each step must be clear and unambiguous.

• Effectiveness: Every step must be given enough information to produce results.

13
Data Structures--> Unit-I: Introduction to Algorithms Pandu Sowkuntla
 Algorithm v/s Program
► An algorithm is a well-defined, systematic ► It is a programming code written using a
logical approach that comes with a step-by- programming language to implement the algorithm
step procedure for computers to solve any of a given problem.
given problem.
► Program can be written in a programming
► We can express algorithms using flowcharts, language and then use a compiler or interpreter
natural language, and many more. (for compiling and interpreting) so that it
becomes understandable for any computer system.
► Algorithm should be finite.
► Program need not be finite.

14
Data Structures--> Unit-I: Introduction to Algorithms Pandu Sowkuntla
 Pseudocode
► We can define or describe an algorithm in two ways:
1. Pseudocode
2. Flowchart
► Pseudocode is an English like representation of the algorithm logic. It is part English,
and part structured code (syntax).
Conventions used in writing Pseudocode
• for, if, else, return and while (similar to C, Java, Python, etc.)

• // is used for commenting.

• and, or & not are boolean operators similar to &&, || & !

• Indentation can be used to represent the body block.

• ==, !=, <, >, <= and >= are used to compare values.

• A[l,r] means a subarray of A, indexed from 'l' to 'r'.

► Note: In this Data Structures course, we use the C programming language syntax in writing
pseudocodes.
15
Data Structures--> Unit-I: Pseudocode and Flowchart Pandu Sowkuntla
 Pseudocode
Example
Algorithm name
Algorithm Max(a, n) Algorithm header

//Algorithm used to find the maximum element in the given array a

of size n Comments

1. begin // Beginning of the algorithm

2. max = a[0]; ‘{‘ can be used to begin
3. for i = 2 to n do
Loop 4. if a[i] > max then
statement 5. max = a[i];
6. end if
7. end for
Conditional return max
8.
statement
9. end // End of the algorithm
‘}‘ can be used to end

a, i, and max are variables

Statement number
Data Structures--> Unit-I: Pseudocode and Flowchart 16
Pandu Sowkuntla
 Flowchart

► Flow chart is the graphical representation of an algorithm

► Different symbols exist to represent different operations of the algorithm.

Flowchart

START
Pseudocode
Input
Step 1: Input M1,M2,M3,M4
M1,M2,M3,M
Step 2: GRADE = (M1+M2+M3+M4)/4 4
Step 3: if (GRADE < 50) then
Print “FAIL” GRADE(M1+M2+M3+M4)/4
else
Print “PASS” N
IS Y
end if
GRADE<50

Print Print
“PASS” “FAIL”

STOP
17
Data Structures--> Unit-I: Pseudocode and Flowchart Pandu Sowkuntla
 Algorithm Efficiency

Need of analyzing efficiency of the Algorithm

for i=2 to n-1 do for i=2 to 𝒏 do

if i divides n if i divides n
n is not prime n is not prime

If division operation takes 1 msec time

Loop executes n-2 times

Loop executes 𝒏 -1 times
If n=12, loop executes 10 times--→10 msec
If n=12, loop executes 3 times--→2 msec

If n=102, loop executes 100 times----→ 100 msec

If n=102, loop executes 10 times----→ 10 msec

If n=1002, loop executes 1000 times---→1000 msec=1 sec

If n=1002, loop executes 31 times---→31 msec

n=1000002, loop executes 1000000 times-→1000*1000

n=1000002, loop executes 1000 times-→1000 msec
=1000 sec
=1 sec
=1000/60=16.6 min

(Values are approximate results)

18
Data Structures--> Unit-I: Algorithm Efficiency Pandu Sowkuntla
 Algorithm Efficiency

Big-O Notation

We don not need to determine the complete measure of the efficiency, only the factor that
determines the magnitude is considered.

The factor is denoted with big-O and read it as “in the order of.”

Algorithm (Efficiency) Analysis Big-O Analysis

► Time complexity of an algorithm is the amount of computer time it needs to run to completion.

► Space complexity of an algorithm is the amount of computer memory it needs to run to completion.

19
Data Structures--> Unit-I: Algorithm Efficiency Pandu Sowkuntla
 Algorithm Efficiency
Time Complexity
1. Linear Complexity

for(i=1; i<=1000; i++) for(i=1; i<=1000; i+=2)

{ {
------ ------
Code Code
------ ------
} }

Loop executes 500 times

Loop executes 1000 times

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

{ {
------ ------
Code Code
------ ------
} }
Loop executes n times Loop executes n/2 times
Complexity is O(n) (in the order of n) Complexity is O(n/2)=O(n)
20
Data Structures--> Unit-I: Algorithm Efficiency Pandu Sowkuntla
 Algorithm Efficiency
Time Complexity
2. Logarithmic Complexity
for(i=1; i<=1000; i*=2) for(i=1000; i>=1; i/=2)
{ {
------ ------
Code Code
------ ------
} }
i=1, iteration=1 i=1000, iteration=1
i=2, iteration=2 i=500, iteration=2
i=4, iteration=3 i=250, iteration=3
i=8, iteration=4 210<=1000 i=125, iteration=4
i=16, iteration=5 1000/ 210>=1 i=62, iteration=5
: log1000=log210=10 :
log1000= =log210=10 :
:
i=512,iteration=10 i=1, iteration=10
i=1024, Ex it i=0, Exit
for(i=1; i<=n; i*=2) for(i=n; i>=1; i/=2)
{ {
------ ------ Code
Code Complexity= O(logn) ------
------
} }
21
Data Structures--> Unit-I: Algorithm Efficiency Pandu Sowkuntla
 Algorithm Efficiency
Time Complexity for (i = 1; i <=n; i++)
{
3. Quadratic Complexity for (j = 1; j <=i; j++)
{
for(i=1; i<=n; i++) ------ Code
{ ------
for(j=1; j<=n; j++) }
{ }
------
Code i=1, j=1, code executes=1 time
------
} i=2, j=1,2 ----→2 times
}
i=3, j=1,2, 3 ----→2 times
:
Code executes n*n times :
i=n, j=1,2, 3….n ----→n times
Time Complexity = O(n2)
Total no. of times =1 + 2 + 3 + … + n
=n(n+1)/2
=(n2+n)/2
=n2/2 + n/2
Time Complexity = O(n2)

22
Data Structures--> Unit-I: Algorithm Efficiency Pandu Sowkuntla
 Algorithm Efficiency

Time Complexity

4. Linear logarithmic Complexity

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

{
Code
for(j=1; j<=n; j*=2)
{
------
------
}
}

Time Complexity = O(nlogn)

23
Data Structures--> Unit-I: Algorithm Efficiency Pandu Sowkuntla
Algorithm Efficiency

T
i
m
e

Practical Time Complexities

Input size n

24
Data Structures--> Unit-I: Pandu Sowkuntla
 Algorithm Efficiency
► Space Complexity

Algorithm Sum(a, n) Variable i takes 1 space

// To find the sum of array elements Variable sum takes 1 space
1. begin Variable a takes n spaces
2. sum=0.0;
3. for i=1 to n do Total space= n+2 spaces + Space for the code
4. sum=sum+a[i];
5. end for
return sum; Space complexity=O(n+2)+c
6.
end =O(n)
7.

Space complexity=Fixed part+ Variable part *Important Note

Types of complexities:

Space for the code Depends on variation in problem 1. Worst case (Big O)
2. Best case
3. Average
(will be discussed in future semesters)

25
Data Structures--> Unit-I: Algorithm Efficiency Pandu Sowkuntla
 Array ADT

26
Data Structures--> Unit-I: Array ADT Pandu Sowkuntla
Sparse Matrices

• A matrix is a two-dimensional data structure consisting of m rows and n columns, with a

total of m x n values.

• 2D-Arrays are used to represent matrices.

• A sparse matrix is one in which the majority of the elements have 0 (zero) value.

Example
► Why would you want to use a new representation? 0 1 2 3
a[0][2]=9,
0 0 0 9 0
▪ To save the storage space. a[1][1]=1,
1 0 1 0 0
a[2][0]=5, 2 5 0 9 0
▪ To reduce the computing time. a[2][2]=9, 3 8 0 0 6
a[3][0]=8, Sparse Matrix
► Sparse Matrix can be represented in two ways: a[3][3]=6 A matrix contains zero values more
than half of its size.
▪ Array representation. (if (no.of zeros > Size(Array)/2))

▪ Linked list representation.

27
Data Structures--> Unit-I: Array ADT Pandu Sowkuntla
Sparse Matrix using Array ADT
First row contains Sparse Matrix representation:b
no. of rows and cols 0 1 2 Total no. of
in the matrix
row col value non-Zero values
0 1 2 3 0 4 4 6
0 0 0 9 0 We store the non-zero elements 0 2 9
with 1
1 0 1 0 0
2 triple: <row, column, value>. 1 1 1
5 0 9 0 2
3 8 0 0 6
3 2 0 5
Sparse Matrix:a 4 2 2 9
5 3 0 8
6 3 3 6

Operations performed on Sparse matrices Row indices Col indices non-Zero values

1. Creation
2. Transpose
3. Addition
4. Multiplication

28
Data Structures--> Unit-I: Array ADT Pandu Sowkuntla
 Algorithm for representing Sparse Matrix

Sparse matrix: a Algorithm SparseM(a, row, col, b)

// Algorithm to represent Sparse matrix
0 1 2 3
begin
0 0 0 9 0 b[0][0] = row;
1 0 1 0 0 b[0][1] = col;
2 5 0 9 0
3 8 0 0 6 k = 1;
for i = 0 to row do
Sparse matrix representation: b for j = 0 to col do
row size varies but col size fixed(=3) if (a[i][j] != 0) then
0 1 2
row col value b[k][0] = i;
0 4 4 6 b[k][1] = j;
0 b[k][2] = a[i][j];
1 2 9
k++;
2 1 1 1 end if
end for
3 2 0 5
end for
4 2 2 9
b[0][2]=k-1;
5 3 0 8
return b;
6 3 3 6 end
Data Structures--> Unit-I: Array ADT 29
Pandu Sowkuntla
Algorithm to Transpose a Sparse Matrix

Original matrix Transposed matrix

row col val row col val for each row i
4 4 5 4 4 5 take element <i, j, value> and
1 2 10 transpose 2 1 10 store it as element <j, i, value> in the
1 4 12 4 1 12 transpose
3 3 5 3 3 5
4 1 15 1 4 15
4 2 12 2 4 12

Required transposed matrix

row col val
transpose 4 4 5 for all elements in j
1 4 15 place element <i, j, value> as
2 1 10 element <j, i, value> in the transpose
2 4 12
3 3 5
4 1 12

Data Structures--> Unit-I: Array ADT Pandu Sowkuntla 30

 Stack Data Structure

31
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
 Stacks
• Stack is a linear data structure in which
items can be inserted and removed only at
one end, called the top.

• The last item inserted into stack, is the

first item to be taken out from the stack.

➢ Operations on Stack

► push(data): adds an element to the top of the stack

► pop(): removes an element from the top of the stack

► peek() or top(): returns a copy of the element on

the top of the stack without removing it.

► is_empty(): checks whether a stack is empty.

► is_full(): checks whether a stack is at maximum

capacity when stored in a static (fixed-size)
structure.

Data Structures--> Unit-I: Stacks 32

Pandu Sowkuntla
 Operations on Stack (Array implementation)
gives top
(Stack size=4) element 30
top()

30 top=2
push(10) push(20) push(30)
(top++) (top++) (top++) 20
20
empty top=1
stack 10 10 10
top=0
initial pop()
top=-1 (top--) Stack
Underflow pop()
(is_empty() required) (top--)

50
top=3
40 40
top=2
Stack 20 20 push(40) 20
push(60) push(50)
Overflow (top++) top=1
(top++) (top++)
(is_full() 10 10 10
required)

Stack full
33
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
Stack implementation
0 1 2 3 4 5 6 7 8 9
Stacks can be implemented in two ways:
stack: 17 23 97 44
1. Arrays.
top = 3
► Easy to implement, but the size of the array is fixed (static)

► Extra memory is not needed for pointer variables.

► It is not dynamic. It doesn’t grow and shrink depending on needs at runtime.

► Performing operation is_full() is required.

2. Linked lists.

► This implementation of a stack can grow and shrink according to the needs
at runtime.

► Extra memory is needed for pointer variables.

34
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
MAX_SIZE = 100 Pseudocodes for Stack Operations
ARRAY stack[MAX_SIZE]
top = -1;
Algorithm: is_empty(top)
Algorithm: is_full(top) begin
begin if (top == -1) then
return True;
if (top == MAX_SIZE – 1) then else
return True; return False;
else end if
return False; end
end if
end

Algorithm: push(stack, top, data) Algorithm: pop(stack, top)

begin begin
if (is_full(top) == True) then if (is_empty(top) == True) then
print("Stack is full"); print("Stack is empty");
else else
top = top + 1; popped_item = stack[top];
stack[top] = data; top = top – 1;
end if end if
return top; return (popped_item, top);
end end
35
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
 Pseudocodes for Stack Operations
Algorithm: peek(stack, top) Time Complexities of operations on stack:
begin
if (is_empty(top) == True) then Operation Time Complexity
print("Stack is empty");
else
peeked_item = stack[top];
1. is_full() O(1)
end if
2. is_empty() O(1)
return peeked_item;
end 3. peek() or top() O(1)

4. push(data) O(1)

5. pop() O(1)

► These all operations do not contain

any loop.

36
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
Applications of Stacks
• Infix expression to Prefix expression.
► Arithmetic Expression
Evaluation. • Infix expression to Postfix expression.

► Expression Conversion. • Evaluating postfix expression.

► Processing functions call.
• Evaluating prefix expression.
► Processing recursive calls (Recursion).

► Backtracking: To track the recursive calls in building optimal solutions.

► Syntax Parsing (in Compilers).

► Memory Management(in Operating Systems).

► Parenthesis Checking.

► String Reversal.

► Text Editors: Undo( ) or Redo ( ) mechanism (Excel, Notepad or WordPad etc.)

► Backward( ) and forward( ) buttons in browser.

37
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
 push(f3())
Processing nested function calls fun3()
{
fun3() ---
main() fun1() { }
{ { ---
pop(f3()) fun1() pop(f1())
---- --- --- fun1()
{
---- --- {
} ----
----
fun1() fun3() }
}
---- --- push(f1())
main()
---- --- main()
{
fun2() } {
---
---
---- push(main()) }
}
----
}
fun4()
{
pop(f4()) ---
fun2() pop(f2()) } fun2()
{
{ fun2() ---
fun2() {
--- {
}
---
--- --- }
main() } main()
push(f2())
fun4() { push(f4()) {
--- --- main() ---
main() {
--- } }
{ ---
} --- }
}
38
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
Processing recursive calls (Recursion)
1*factorial(0) returns 1*1=1
#include<stdio.h> Example: n=5 (since factorial(0)=1)

int factorial(int n); 2*factorial(1)

returns 2*1=2
(since factorial(1)=1)
int main() 3*factorial(2)
{
returns 3*2=6
int n;
(since factorial(2)=2)
printf("Enter a positive integer: "); 4*factorial(3)
scanf("%d",&n); returns 4*6=24
printf("Factorial of %d = %d", n, factorial(n)); (since factorial(3)=6)
5*factorial(4)
} returns 5*24=120
(since factorial(4)=24)
main)()
int factorial(int n)
{
if (n>=1)
return n*factorial(n-1); main() function prints Factorial of 5=120
else
return 1;
}

39
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
Expression Representation
Infix x + y Operator between
operands.
Popular methods used for Prefix + x y Operator before
representation of an expression operands.
Postfix x y + Operator after
operands.

Precedence/Associativity table

Operators Associativity Precedence

^ exponentiation Right to left Highest followed by

*Multiplication and
/division

* Multiplication, Left to right Highest followed by +

/ division addition and -
subtraction

+ addition, Left to right lowest

- subtraction

40
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
Converting Infix to Postfix
Example-1: 3*3/(4-1)+6*2
Algorithm for converting Infix to Postfix
Step 1: Consider the next element in the input. Expression Stack Output
Step 2: If it is operand, display it.
Step 3: If it is opening parenthesis, insert it on stack. 3 Empty 3
* * 3
Step 4: If it is an operator, then
3 * 33
• If stack is empty, insert operator on stack.
• If the top of stack is opening parenthesis, insert / / 33*
the operator on stack ( /( 33*
• If it has higher priority than the top of stack,
insert the operator on stack. 4 /( 33*4
• Else, delete the operator from the stack and - /(- 33*4
display it, repeat Step 4.
1 /(- 33*41
Step 5: If it is a closing parenthesis, delete the ) / 33*41-
operator from stack and display them until an opening + + 33*41-/
parenthesis is encountered. Delete and discard the opening
parenthesis. 6 + 33*41-/6
* +* 33*41-/6
Step 6: If there is more input, go to Step 1.
2 +* 33*41-/62
Step 7: If there is no more input, delete the remaining Empty 33*41-/62*+
operators to output.
Data Structures--> Unit-I: Stacks 41
Pandu Sowkuntla
Converting Infix to Postfix
Example-1: 3 * 3 / ( 4 - 1 ) + 6 * 2 Example-2: (a*b) + (d-c)

ab* + dc-

ab*dc-+

Example-3: a + b / c + d * (e-f) ^ g

a + b / c + d * ef- ^g

a + b / c + d * ef-g^

a + bc/ + d * ef-g^*
Example-4: K + L - M*N + (O^P) * W/U/V * T + Q
a + bc/ + def-g^*

abc/+ + def-g^*

abc/+def-g^*+

42
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
Converting Infix to Prefix
Algorithm for Infix to Prefix Conversion:

Step 1: Insert “)” onto stack, and add “(” to end of the expression .

Step 2: Scan expression from right to left and repeat Step 3 to 6 for each element of A
until the stack is empty .

Step 3: If an operand is encountered, add it to output .

Step 4: If a right parenthesis is encountered, insert it onto stack .

Step 5: If an operator is encountered then,

a. Delete from stack and add to output (each operator on the top of stack)
which has same or higher precedence than the operator.
b. Add operator to stack.

Step 6: If left parenthesis is encountered then ,

a. Delete from the stack and add to B (each operator on top of stack until a
left parenthesis is encountered).
b. Remove the left parenthesis.

Step 7: Exit
43
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
Converting Infix to Prefix

Example-1: (a*b) + (d-c) Example-2: a + b / c + d * (e-f) ^ g

Example-3: K + L - M*N + (O^P) * W/U/V * T + Q

44
Data Structures--> Unit-I: Pandu Sowkuntla
Postfix expression evaluation Example infix expression: 2 * ( 4 + 3 ) – 5

Algorithm for evaluating postfix expression Equivalent postfix: 2 4 3 + * 5-

Step-1: Read all the symbols one by one from

left to right in the given Postfix
Expression

Step-2: If the reading symbol is operand,

then push it on to the Stack.

Step-3: If the reading symbol is operator

(+ , - , * , / etc.,), then perform TWO pop
operations and store the two popped operands
in two different variables (operand1 and
operand2). Then perform reading symbol
operation using operand1 and operand2 and
push result back on to the Stack.

Step-4: Finally! perform a pop operation and

display the popped value as final result.

45
Data Structures--> Unit-I: Pandu Sowkuntla
Postfix expression evaluation

Example infix expression: 2 * ( 4 + 3 ) – 5

Input Stack Operation
Equivalent postfix: 2 4 3 + * 5-
2 2
4 2 4
3 2 4 3
+ 2 4+3=7
2 7
* empty 2*7=14
14
5 14 5
- empty 14-5=9
9
No i/p empty 9

46
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
Prefix expression evaluation

Example infix expression: 2 * (4+3) – 5 Note: Prefix notation also known as Polish
Notation or Warsaw notation, and Postfix
Equivalent prefix: - 5 * 2 + 4 3 notation is also known as Reverse Polish
notation
Reverse of prefix: 3 4 + 2 * 5 -

Reverse of prefix: 3 4 + 2 * 5 –

Above expression is evaluated according the

algorithm of evaluating postfix expressions.

47
Data Structures--> Unit-I: Stacks Pandu Sowkuntla
 Queue Data Structure

48
Data Structures--> Unit-I: Queues Pandu Sowkuntla
Queues
• Queue is a linear data structure, where a
data item insertion is done at one end
(called rear) and deletion is performed at
the other end (called front).

• Accessing the elements of queue follows a

First In, First Out (FIFO) order.

➢ Operations on Queue

► enqueue(data): This is used to add elements into

the queue at the rear (back) end.

► dequeue(): removes an element from the queue at the

rear front end of the queue.

► is_empty(): checks whether a queue is empty.

front
► is_full(): checks whether a queue is at maximum
capacity when stored in a static (fixed-size)
structure.
49
Data Structures--> Unit-I: Queues Pandu Sowkuntla
Queue implementation front = 0 rear = 3

Queues can be implemented in two ways:

Queue: 17 23 97 44
1. Arrays.

► Easy to implement, but the size of the array is fixed (static)

► Extra memory is not needed for pointer variables.

► It is not dynamic. It doesn’t grow and shrink depending on needs at runtime.

► Performing operation is_full() is required.

2. Linked lists.

► This implementation of a stack can grow and shrink according to the needs
at runtime.

► Extra memory is needed for pointer variables.

50
Data Structures--> Unit-I: Queues Pandu Sowkuntla
Operations on Queues (Array implementation)
rear = -1

Initial Queue(empty queue)

dequeue()
returns Queue Underflow
Front = -1

rear=0 rear=1 rear=2 rear=2 rear=2

3 3 6 3 6 9 6 9 9

Queue full
front=0 front=0 front=0 front=1 front=2

enqueue(3) enqueue(6) dequeue() dequeue()

enqueue(9)
rear++ rear++ front++ front++
rear++;
front++ enqueue() returns
Queue Overflow
51
Data Structures--> Unit-I: Queues Pandu Sowkuntla
Array implementation of Queue void dequeue()
{
#define SIZE 20 if(front == -1)
void enqueue(int); printf("\nQueue is empty");
void dequeue(); else
void read(); {
int queue[SIZE], front = -1, rear = -1; printf(“Successfully deleted\n”);
printf("Deleted ele : %d", queue[front]);
front++;
if(front == SIZE)
void enqueue(int value) front = rear = -1;
{ }
if(rear == SIZE-1) }
printf("\n Queue is full");
else void read()
{ {
if(front == -1) if(rear == -1)
front = 0; printf("\nQueue is Empty!!!");
rear++; else
queue[rear] = value; {
printf("\n Successfully inserted!!!"); int i;
} printf("\nQueue elements are:\n");
} for(i=front; i<=rear; i++)
printf("%d\t",queue[i]);
}
Data Structures--> Unit-I: Queues
} Pandu Sowkuntla
52
Problems with Linear queues
front = 0 rear = 3

queue: 17 23 97 44
• If the rear of the queue is at
0 1 2 3 4 5 6 7 the end of the array (the highest
index).
enqueue(333) 17 23 97 44 333
• Even if there are empty cells at
0 1 2 3 4 5 6 7
the beginning of the array, rear
can't go any further.
dequeue() 23 97 44 333
0 1 2 3 4 5 6 7 • Because all the elements are
After some front = 1 removed, the rear points to end
insertions rear = 4
of queue (the highest index).
and deletions

dequeue() 10 20 30 40 • Hence a new element can not be

inserted.
0 1 2 3 4 5 6 7
After all front = 4
deletions
rear = 7

if front=SIZE of array then

Empty queue: rear=front=-1;
0 1 2 3 4 5 6 7
rear = 7 front = 8
Data Structures--> Unit-I: Queues Pandu Sowkuntla 53
 Circular queues
An array holding the queue elements as circular (joined at the ends)

0 1 2 3 4 5 6 7

10 20 30 40 50
Queue:

front = 0 rear = 4

➢ Advantages of circular queue are: Initial

rear = -1, front= -1
▪ Easier for insertion-deletion: Elements
can be inserted easily if there are (when Queue is empty)
vacant locations.
➢ Elements were added to this queue in the order
10, 20, 30, 40, 50, and will be removed in the
▪ Efficient utilization of memory: No
same order
wastage of memory as it uses the
unoccupied space. • Index of front = (front + 1) % Queue.length;

• Index of rear = (rear + 1) % Queue.length;

Data Structures--> Unit-I: Queues
Applications of queues

► When a resource is shared among multiple consumers.

Examples: CPU scheduling, Disk Scheduling.

► When data is transferred asynchronously (data not necessarily received at same rate as
sent) between two processes.

Examples: IO Buffers, pipes, file IO, printer queue etc.

► Data packets waiting to be transmitted over the Internet.

► Queue used to model real-world situations.

Examples: People waiting in line at a bank, airplanes waiting to take off, stores and
reservation centres,. Etc.

Data Structures--> Unit-I: Queues Pandu Sowkuntla

55