2nd puc computer science chapter 3 data structures 1

Ashwini E DATA STRUCTURES
ashwinieswre@gmail.com
Ashwini e Youtube channel Study With Me Ashwini E
Chapter 4
Data Structures
Data Structures
Introduction:
Data is a collection of raw facts that are calculated or manipulated by
computers. Data may contain single value or set of values.

For example students’ name may contain three sub items like first name,
middle name, and last name whereas students’ regno can be treated as a single
item. These data have to be processed to form information.
In order to process the data the data should be organized in a particular way.
This leads to structuring of data. Utilization of space by data in memory and
optimization of time taken for processing, plays an important role in data
structures.
Data structure means organization or structuring a collection of data items
in appropriate form so as to improve the efficiency of storage and processing.
Definition: A data structure is a specialized format for organizing and storing
data.
Data representation:
The process of storing the data which is require for processing in computer
memory is known as data representation. Data may be of same type or different
type. Data structure is a method of storing data in memory so that it can be used
efficiently. The study of data structure mainly dea1s with:
➢ Logical or mathematical description of structure.
➢ Implementation of structure on a computer.
➢ Analysis of structure which includes determining amount of space in memory
and optimization of time taken for processing.
Classification of data structures:
Primitive data structures:
Data structures that are directly operated upon by machine-level
instructions are known as primitive data structures.
The integer, real (float), logical data, character data, pointer and reference
are primitive data structures.
Data
structures
Primitive data
structures
Integer
Float
Character
Pointer
Non-Primitive data
structures
Arrays
One Dimensional
Two Dimensional
Multi Dimensional
Lists
Linear
Data
structures
Stack
Queue
Linked List
Non-Linear
Data
structures
Tree
GraphFiles

Operations on primitive data structures:
The various operations that can be performed on primitive data structure are:
Create: Create operation is used to create a new data structure. This operation
reserves memory space for the program elements. It can be carried out at compile
time and run-time.
For example: int x;
Destroy: Destroy operation is used to destroy or remove the data structures from
the memory space. When the program execution ends, the data structure is
automatically destroyed and the memory is de-allocated. C++ allows the destructor
member function destroy the object.
Select: Select operation is used by programmers to access the data within data
structure. This operation updates or alters data.
Update: Update operation is used to change data of data structures. An assignment
operation is a good example of update operation.
For example:
int x = 2; Here, 2 is assigned to x.
Again, x = 4; 4 is reassigned to x. i.e., x value is updated (old
value 2 is replaced by new value 4)
Non primitive data structures:
Non-primitive data structures are more complex data structures. These data
structures are derived from the primitive data structures. They are the formation
of groups of homogeneous (same type) and heterogeneous (different type) data
elements.
Non-primitive data structures are classified as arrays, lists and files. Data
structures under lists are classified as linear and non-linear data structures.
Linear data structure:
Linear data structures are a kind of data structure that has homogenous
elements. Each element is referred to by an index. The linear data structures are
Stack, Queues and Linked Lists.
Data elements of linear data structures will have linear relationship between
data elements. One of the methods is to have linear relationship between elements
by means of sequential memory locations. The other method is to have linear
relationship between data elements by means of pointers or links.
Non-linear data structure:
A non-linear data structure is a data structure in which a data item is
connected to several other data items. The data item has the possibility to reach
one or more data items. The data items are not arranged in a sequential structure.
Trees and Graphs are the examples of non-linear data structures.
Operations on linear data structure:

The basic operations on non-linear data structures are as follows:
➢ Traversal: The process of accessing each data item exactly once to perform
some operation is called traversing.
➢ Insertion: The process of adding a new data item into the given collection
of data items is called insertion.
➢ Deletion: The process of removing an existing data item from the given
collection of data items is called deletion.
➢ Searching: The process of finding the location of a data item in the given
collection of data items is called as searching.
➢ Sorting: The process of arrangement of data items in ascending or
descending order is called sorting.
➢ Merging: The process of combining the data items of two structures to form
a single structure is called merging.
Arrays
An array is a collection of homogeneous elements with unique name and the
elements are arranged one after another in adjacent memory location.
The data items in an array are called as elements. These elements accessed
by numbers called as subscripts or indices. Since the elements accessed using
subscripts, arrays are also called as subscripted variables.
Types of Arrays: There are three types of arrays:
o One-dimensional Array
o Two-dimensional Array
o Multi-dimensional array
One-dimension Array:
An array with only one row or column is called one-dimensional array. It is
finite collection of n number of elements of same type in which each element is
referenced by one subscript (index).
Array can be denoted as:
data type arrayname[size]; Here, size specifies the number of
elements in the array and the index (subscript) values ranges from 0 to n-l (if there
are n elements).
Example: int a[5];
Features:
✓ Array size should be positive number only.
✓ String array always terminates with null character (‘0’ )
✓ Array elements are counted from 0 to n-l.
Calculating the length of Array:
Arrays can store a list of finite number (n) of data items of same data
type in consecutive locations. The number n is called size or length of the array.
The length of an array can be calculated by
L = UB – LB + 1
Here, UB is the largest index and LB is the smallest index of an array.
Example: If an array A has values 10, 20, 30, 40, 50, 60 stored in locations

0, 1, 2, 3, 4, 5 then UB=5 and LB=0
Size of the array is L = 5 – 0 + 1 = 6
Representation of one-dimensional arrays in memory:
Elements of linear array are stored in consecutive memory locations. Let P
be the location of the element. Address of first element of linear array A is given by
Base(A) called the Base address of A. Using this we can calculate the address of
any element of A by the formula:
LOC(A[P]) = Base(A) + W(P – LB)
Here W is the number of words (bytes) per memory cell.
Example: Suppose if a string S is used to store a string ABCDE in it with
starting address at 1000, one can find the address of fourth element (i.e.,S[3]) as
follows:
Address(A[P]) = Base(A) + W(P-LB)
Address(S[3]) = 1000 + 1(3-0) (W is 1 for characters)
= 1003
1000 1001 1002 1003 1004
A B C D E
S[0] S[1] S[2] S[3] S[4]
Basic operations on one-dimensional arrays:
The following operations are performed on arrays:
1. Traversing: Accessing each element of the array exactly once to do some
operation.
2. Searching: Finding the location of an element in the array.
3. Sorting: Arranging the elements of the array in some order.
4. Insertion: Inserting an element into the array.
5. Deletion: Removing an element from the array.
6. Merging: Combining one or more arrays to form a single array.
Traversing a Linear Array:
Traversing is the process of visiting each subscript at least once from
beginning to last element.
For example, to find the maximum element of the array we need to access
each element of the array.
Algorithm: Let A be a linear array with LB and UB as lower bound and upper bound.
This algorithm traverses the array A by applying the operation PROCESS to each
element of A.
1. For LOC = LB to UB
PROCESS A[LOC]
End of for
2. Exit

Program: To input and output the elements of the array.
#include<iostream.h>
#include<iomanip.h>
#include<conio.h>
void main( )
{
int a[10], i, n;
clrlcr( ) ;
cout<<“How many elements?”;
cin>>n;
cout<<“Enter the elements”;
for(i=0; i<=n-1; i++)
cin>>a[i];
cout<<“The elements are”;
for(i=0; i<=n-1; i++)
cout<<setw(4)<<a[i];
getch( );
}
Searching an element:
It refers to finding the location of the element in a linear array. There are
many different algorithms. But the most common methods are linear search and
binary search.
Linear Search
This is the simplest method in which the element to be searched is compared
with each element of the array one by one from the beginning till end of the array.
Since searching is one after the other it is also called as sequential search or linear
search.
Algorithm: A is the name of the array with N elements. ELE is the element to be
searched. This algorithm finds the location loc where the searching element ELE is
stored.
Step 1: LOC = –1
Step 2: For I = 0 to N-l
if(A[I] = ELE)
LOC=I
GOTO Step 3
Step 3: If (LOC >=0)
PRINT LOC
else
PRINT "Search is unsuccessful"
End of if
End of for
Step 4: Exit
Program: To find the location of an element.

#include<conio.h>
#include<iomanip.h>
void main( )
{
int a[50], i, n, ele, pos;
clrscr( );
cout<<“Enter the number of elements”<<endl;
cin>>n;
cout<<“Enter the elements”<<endl;
for(i=0; i<=n-1; i++)
cin>>a[i];
cout<<“Enter the searching element”<<endl;
cin>>ele;
pos=-1;
for(i=0; i<=n-1; i++)
if (ele == a[i])
{
pos=i;
break;
}
if (pos>=0)
cout<<ele<<“ is present at position”<<pos<<endl;
else
cout<<ele<<“ is not present”<<endl;
getch( );
}
Binary Search:
When the elements of the array are in sorted order, the best method of
searching is binary search. This method compares the element to be searched I
with the middle element of the array. If the comparison does not match the element
is searched either at the right-half of the array or at the left-half of the array.
Let B and E denote the beginning and end locations of the array. The middle
element A[M] can be obtained by first finding the middle location M by
M = int(B+E)/2, where int is the integer value of the expression.
If A[M] = ELE, then search is successful. Otherwise a new segment is found
as follows:
1. If ELE<A[M] , searching is continued at the left-half of the segment.
Reset E=M-l.
2. If ELE>A[M], searching is continued at the right-half of the segment.
Reset B=M+l.
3. If ELE not found then we get a condition B>E. This results in
unsuccessful search.
Algorithm: A is the sorted array with LB as lower bound and UB as the upper
bound respectively. Let B, E, M denote beginning, end and middle locations of the
array A.
Step 1: set B = LB, E = UB

Step 2: while (B <= E)
M = int(B+E)/2
if(ELE = A[M]
LOC = M
GOTO 4
else
if(ELE < A[M])
E = M-1
else
B = M+1
End of while
Step 4: if(LOC >= 0)
PRINT “Element found in the location”, LOC
else
PRINT “Unsuccessful search”
Step 5: Exit
Program: To find the location of an element using Binary search.
#include<conio.h>
#include<iomanip.h>
void main( )
{
int a[100], i, n, m, loc, b, e, pos, ele;
clrscr( );
cout<<"How many elements?"<<endl;
cin>>n;
cout<<"Enter the elements in ascending order"<<endl;
for(int i=0; i<n; i++)
cin>>a[i];
cout<<"Enter the searching element:"<<endl;
cin>>ele;
pos= -1;
b=0;
e=n-1;
while(b<=e)
{
m=(b+e)/2;
if(ele==a[m])
{
pos=m;
break;
}
else
if(ele<a[m])
e=m-1;
else
b=m+1;

}
if(pos>=0)
cout<<"The element found in the location "<<pos;
else
cout<<"Search is unsuccessful";
getch( );
}
Insertion:
Insertion refers to inserting an element into the array. A new element can be
inserted provided the array should be large enough to accommodate the new
element.
When an element is to be inserted into a particular position, all the elements
from the asked position to the last element should be shifted into the higher order
positions.
Example: Let A be an array with items 10, 20, 40, 50 and 60 stored at consecutive
locations. Suppose item=30 has to be inserted at position 2. The following
procedure is applied.
➢ Move number 60 to position 5.
➢ Move number 40 to position 3
➢ Position 2 is blank.
➢ Insert 30 into the position 2. i.e., A[2] = 30.
Algorithm A is the array with N elements.
ITEM is the element to be inserted in the position P.
Step 1: for I = N-1 downto P
A[I+1] = A[I]
End of for
Step 2: A[P] = ITEM
Step 3: N = N+1
Step 4: Exit
Program: To insert an element into the array.
#include<stdlib.h>
void main( )
{
int a[10], i, n, ele, p;
cout<<"How many elements? ";
cin>>n;
cout<<"Enter the elements: ";
for(i=0; i<=n-1; i++)
cin>>a[i];
cout<<"Enter the element to be inserted: ";
10
20
40
50
60
A[0]
A[1]
A[2]
A[3]
A[4]
10
20
30
40
50
60
A[0]
A[1]
A[2]
A[3]
A[4]
A[5]

cin>>ele;
cout<<"Enter the position 0 to "<<n<<;
cin>>p;
if(p > n)
{
cout<<"Invalid position";
exit(0);
}
else
{
for(i=n-1; i>=p; i--)
a[i+1] = a[i];
a[p] = ele;
n=n+1;
cout<<"The array after insertion is ”;
for(i=0; i<=n-1; i++)
}
}
Deletion:
Deletion refers to removing an element into the array. When an element is to
be deleted from a particular position, all the subsequent shifted into the lower order
positions.
Example: Let A be an array with items 10, 20, 30, 40
and 50 stored at consecutive locations. Suppose
ele=30 has to be deleted at position 2.
The following procedure is applied.
➢ Copy 30 to ele. i.e., ele = 30
Before deletion After deletion
10
20
40
50
A[0]
A[1]
A[2]
A[3]
10
20
30
40
50
A[0]
A[1]
A[2]
A[3]
A[4]

PSM-SRKVS Data Structures 11
Algorithm: A is the array with N elements. The element to be deleted in the position
P and it is stored into the variable ele.
Step 1: ele = A[P]
Step 2: for I = P+1 to N-1
A[I-1] = A[I]
End of for
Step 3: N = N-1
Step 4: Exit
Program: To delete an element from the array.
#include<stdlib.h>
void main( )
{
int a[10], i, n, ele, p;
cout<<"How many elements? ";
cin>>n;
cout<<"Enter the elements: ";
for(i=0; i<=n-1; i++)
cin>>a[i];
cout<<"Enter the position: 0 to "<<n-1<<;
cin>>p;
if (p > n-1)
{
cout<<"Invalid position";
exit(0);
}
else
{
ele = a[p];
for(i=p+1; i<=n-1; i++)
a[i-1] = a[i];
n=n-1;
cout<<"The elements after the insertion are ";
for(i=0; i<=n-1; i++)
}
}
Sorting the elements:
Sorting is the arrangement of elements of the array in some order. There are
various methods like bubble sort, shell sort, selection sort, quick sort, heap sort,
insertion sort etc. But only insertion sort is discussed in this chapter.
Insertion Sort:

The first element of the array is assumed to be in the correct position. The
next element is considered as the key element and compared with the elements
before the key element and is inserted in its correct position.
Example: Consider the following list of numbers stored in the consecutive locations.
Step 1: Assuming 70 in correct position 30 is
compared with 70. Since 30 is less than 70, exchange these two elements. Now the
list now is
Step 2: Now 40 is the key element. First it is compared with 70. Since it is lesser
than 70, exchange these two elements. Next compared with 30. Since 40 is greater
than 30, no exchange. Now the list now is
Step 3: Now 10 is the key element. First it is compared with 70. Since it is less it is
exchanged. Next it is compared with 40 and it is exchanged. Finally it is compared
with 30 and placed in the first position. The list now is
Step 4: Now 80 is the key element and compared with the sorted elements and
placed in the position. Since 80 is greater than 70 it retains its position. Finally,
the sorted list is
Algorithm: Let A be an array with N unsorted elements. The following algorithm
sorts the elements in order.
Step 1: for i = 1 to N-1
Step 2: j = i
Step 3: while( j >= 1 )
if( A[j] < A[j-1])
temp = A[j]
A[j] = A[j-1]
A[j-1] = temp
if end
Step 4: j = j -1
End of while
End of for
Step 5: Exit.
Two-dimensional arrays:
70 30 40 10 80
30 70 40 10 80
30 40 30 10 80
10 30 40 70 80
10 30 40 70 80

A two dimensional array is a collection of elements and each element is
identified by a pair of indices called as subscripts. The elements are stored in
contiguous memory locations.
We logically represent the elements of two-dimensional array as rows and
columns. If a two-dimensional array has m rows and n columns then the elements
are accessed using two indices I and J, where 0≤I≤m-1 and 0≤J≤n-1 OR 1≤I≤m and
1≤J≤n.
Thus the expression A[I][J] represent an element present at Ith row and Jth
column of the array A.
The number of rows and columns in a matrix is called as the order of the
matrix and denoted as m x n. The number of elements can be obtained by
multiplying number of rows and number of columns.
Representation of 2-dimensional array in memory:
Suppose A is the array of order m x n. To store m*n number of elements, we
need m*n memory locations. The elements should be in contiguous memory
locations.
There are two methods:
• Row-major order
• Column-major order
Row-major order:
Let A be the array of order m x n. In row-major order, all the first-row
elements are stored in sequential memory locations and then all the second-row
elements are stored and so on.
Example: Consider the array of order 3 x 3.
Base(A) is the address of the first element. The memory address of any
element A[I][J] can be obtained by the formula
LOC(A[I][J]) = Base(A) + W [ n(I – l) + (J – l) ]
where W is the number or words per memory location. (Here A[1][1] is the
first element location).
Column-major order:
2
5
-8
3
9
7
4
-6
1
A[0][0]
A[0][1] First row
A[0][2]
A[1][0]
A[1][1] Second row
A[1][2]
A[2][0]
A[2][1] Third row
A[2][2]
A[0]
A[1]
A[2]
[0] [1] [2]

Let A be the array of order m x n. In column-major order, all the first- column
elements are stored in sequential memory locations and then all the second-column
elements are stored and so on.
Example: Consider the array of order 3 x 3.
Base(A) is the address of the first element. The memory address of any
element A[I][J] can be obtained by the formula,
LOC(A[I][J]) = Base(A) + W [ (I – l) + m(J – l) ]
Here, W is the number of words per memory. (Here A[1][1] is the first
element location).
Example Consider the array A of order 25 x 4 with base value 2000 and one word
per memory location. Find the address of A[12][3] in row-major order and column-
major order. Here the array starts from A[1][1].
Solution: Given, Base(A) = 2000, m = 25, n = 4, W = 1, I = 12, J = 3
Row-major order: LOC(A[I][J]) = Base(A) + W[n(I-1) + (J-1)]
LOC(A[12][3]) = 2000 + 1[4(12-1)+(3-1)]
= 2000 + (4(11) + 2)
= 2000 + 44 + 2
= 2046
Column-major order: LOC(A[I][J]) = Base(A) + W[ (I-1) + m(J-1)]
LOC(A[12][3]) = 2000 + 1[(12-1)+25(3-1)]
= 2000 + 1(11 + 50)
= 2000 + 61
= 2061
Program: To read and print the elements in column-major order.
A[0]
A[1]
A[2]
[0] [1] [2]
2
5
-8
3
9
7
4
-6
1
A[0][0]
A[1][0] First column
A[2][0]
A[0][1]
A[1][1] Second column
A[2][1]
A[0][2]
A[1][2] Third column
A[2][2]

#include<iomanip.h>
void main( )
{
int a[5][5], i, j, m, n;
cout<<"Enter the order: ";
cin>>m>>n;
cout<<"Enter the elements: "<<endl;
for(i=0; i<=n-1; i++)
for(j=0; j<=m-1; j++)
cin>>a[j][i];
cout<<"The matrix in column-major order is: "<<endl;
for(i=0; i<=m-1; i++)
{
for(j=0; j<=n-1; j++)
cout<<setw(4)<<a[i][j];
cout<<endl;
}
}
Applications of arrays:
1. Arrays are used to implement other data structures such as heaps, hash
tables, queues, stacks and strings etc.
2. Arrays are used to implement mathematical vectors and matrices.
3. Many databases include one-dimensional arrays whose elements are records.
Advantages of arrays:
1. It is used to represent multiple data items of same type by using only single
name.
2. It can be used to implement other data structures like linked lists, stacks,
queues, trees, graphs etc.
3. Two-dimensional arrays are used to represent matrices.
Disadvantages of arrays:
1. We must know in advance that how many elements are to be stored in array.
2. Array is static structure. It means that array is of fixed size. The memory which
is allocated to array cannot be increased or reduced.
3. Since array is of fixed size, if we allocate more memory than requirement then
the memory space will be wasted. If we allocate less memory than
requirement, then it will create problem.
4. The elements of array are stored in consecutive memory locations. So
insertions and deletions are very difficult and time consuming.
STACKS

A stack is an ordered collection of items where the insertion and removal of
an item always take place at only one end. This end is commonly referred to as the
“top”. The end opposite to top is the base.
The most recently added item is the one that is to be removed first. This
ordering principle is sometimes called LIFO, last-in first-out. Newer items are near
the top, while older items are near the base.
Examples:
• Cafeteria has a stack of trays or plates where you take the one at the top,
uncovering a new tray or plate for the next customer in line.
• Imagine a stack of books on a desk. The only book whose cover is visible is
the one on top. To access others books in the stack, we need to remove the ones
that are placed on top of them.
Stacks are fundamentally important, as they can be used to reverse the order
of items. The order of insertion is the reverse of the order of removal.
Every web browser has a Back button. As you navigate from web page to web page,
those pages are placed on a stack (actually it is the URLs that are going on the
stack). The current page that you are viewing is on the top and the first page you
looked at is at the base. If you click on the Back button, you begin to move in
reverse order through the pages.
Representation of stacks in memory:
The representation of a stack in the memory can be done in two ways.
▪ Static representation using arrays
▪ Dynamic representation using linked lists
Array representation of a stack:
Stack can be represented using a one-dimensional array. The items into the
stack are stored in a sequential order from the first location of the memory block.
A pointer TOP contains the location of the top element of the stack. A variable
MAXSTK contains the maximum number of elements that can be stored in the
stack. The condition TOP = MAXSTK-1 indicates that the stack is full and TOP =
NULL indicates that the stack empty.
Push Pop
TOP
S
K
O
O
B
B O O K S

Note: Representing a stack using arrays is easy and convenient. It is useful for fixed
sized stacks. If the size of a stack is required to increase during execution (dynamic
allocation), it is not possible using arrays. This requires linked list.
Linked list representation of a Stack:
The size of the array needs to be fixed to store the items into the stack. If the
stack is full we cannot insert an additional item into the array. It gives an overflow
exception. But in linked list we can increase the size at runtime by creating a new
node. So it is better to implement stack data structure using Linked list data
structure.
Insertion:
Insertion operation refers to
Inserting an element into stack. We create
a new node and insert an element into the
stack.
To follow the stack principle “Last-in-first-out” an element should be inserted at
the end of the linked list.
Deletion:
Deletion operation of an element refers to deleting a node from the Linked
list.
Deletion can be done by deleting the
top-most item from the stack. So to delete
an item, the last node of the linked list is
deleted.
Operations on Stack:
The stack is abstract data type. A stack is an ordered collection of items
where items are added to and removed from the end called the “top.” Stacks are
ordered LIFO
stack(): Creates a new stack that is empty. It needs no parameters and returns
an empty stack.
push(item): Adds a new item to the top of the stack. It needs the item and
returns nothing.
pop():Removes the top item from the stack. It needs no parameters and returns
the item. The stack is modified.
peek(): Returns the top item from the stack but does not remove it. It needs no
parameters. The stack is not modified.
START
50 25 37 NULL

isEmpty(): Tests whether the stack is empty. It needs no parameters and returns
a Boolean value.
size():Returns the number of items on the stack. It needs no parameters and
returns an integer.
Algorithm for PUSH Operation:
STACK is the array that contains N elements and TOP is the pointer to the
top element of the array. ITEM the element to be inserted. This procedure inserts
ITEM into the STACK.
Step 1: If TOP = N-1 then [Check overflow]
PRINT "Stack is full"
Exit
End of If
Step 2: TOP=TOP + 1 [Increment the TOP]
Step 3: STACK[TOP]=ITEM [Insert the ITEM]
Step 4: Return
Algorithm for POP Operation:
STACK is the array that store N items. TOP is the pointer to the top element
of the array. This procedure delete the top element from STACK.
Step 1: If TOP = 0 then [Check underflow]
PRINT "Stack is empty"
Exit
End of If
Step 2: ITEM=STACK[TOP] [Copy the TOP element]
Step 3: TOP = TOP – 1 [Decrement the TOP]
Step 4: Return
Application of Stacks
• The simplest application of a stack is to reverse a word. You push a given
word to stack - letter by letter - and then pop letters from the stack.
• Another application is an “undo” mechanism in text editors; this operation
is accomplished by keeping all text changes in a stack.
• Used in Backtracking.
( Backtracking: This is a process when you need to access
the most recent data element in a series of elements. Think
of a labyrinth or maze - how do you find a way from an
entrance to an exit? Once you reach a dead end, you must
backtrack. But backtrack to where? to the previous choice
point. Therefore, at each choice point you store on a stack
all possible choices. Then backtracking simply means
popping a next choice from the stack ).
• Stacks are used in recursion.
• Conversion of decimal number into binary
• To solve tower of Hanoi
• Conversion of infix expression into prefix and postfix.

Arithmetic expression: An expression is a combination of operands and operators
that after evaluation results in a single value. Operands consist of constants and
variables. Operators consists of ( , +, - , * , /, ), … etc.,
Expressions can be
(i) Infix expression (ii) Post fix expression (iii) Prefix expression
(i) Infix expression: If an operator is in between two operands it is called infix
expression.
Example: a + b
(ii) Postfix expression: If an operator follows the two operands it is called post fix
expression.
Example: ab+
Prefix expression: If an operator precedes two operands, it is called prefix
expression.
Example: +ab
Algorithm for Infix to Postfix:
1. Examine the next element in the input.
2. If it is operand, output it.
3. If it is opening parenthesis, push it on stack.
4. If it is an operator, then
• If stack is empty, push operator on stack.
• If the top of stack is opening parenthesis, push operator on stack
• If it has higher priority than the top of stack, push operator on stack.
• Else pop the operator from the stack and output it, repeat step 4.
5. If it is a closing parenthesis, pop operators from stack and output them until
an opening parenthesis is encountered. Pop and discard the opening parenthesis.
6. If there is more input go to step 1.
7. If there is no more input, pop the remaining operators to output.
Example: Convert 2 * 3 / (2 – 1) + 5 * 3 into post fix expression.
Expression Stack Output
2 Empty 2
* * 2
3 * 23
/ / 23*
( /( 23*
2 /( 23*2
– /(– 23*2
1 /(– 23*21
) / 23*21–
+ + 23*21–/
5 + 23*21–/5
* +* 23*21–/5
3 +* 23*21–/53
Empty 23*21–/53*+
QUEUES

2nd puc computer science chapter 3 data structures 1

More Related Content

What's hot

Similar to 2nd puc computer science chapter 3 data structures 1

More from Aahwini Esware gowda

Recently uploaded

2nd puc computer science chapter 3 data structures 1