Introduction to Data Structures

Definition and Use of Data Structure

• a way of organizing all data items that considers not
only the elements stored but also their logical
relationship to each other
• defined as a mathematical or logical model of
organizing the data items into computer memory in
such a way that they can be used efficiently
• the purpose of studying data structure is to learn how
to organize data into memory so that it can be
accessed quickly and conveniently.
• refers to the study of data and representation of data
objects within the program i.e., the implementation of
structured relationships among different data objects.
Example: lists, stacks, queues, heaps, search trees,
hash tables, etc.
• Different sets of operations can be performed on different data
structures are accessing, traversing, inserting, deleting, modifying etc.
While writing a program, a minimal data structure must be chosen
that supports all the operations as per need.
• Data Structure can be used for the following purpose:
i) Organizing the data – How data items are organized in the main memory?
ii) Accessing methods – How data items can be accessed?
iii) Specifying the degree of associativity – How data items are interrelated?
iv) Processing alternatives for data – How many different ways are there in
which these data items can be processed?
Algorithm + Data Structure = Program
Types of Data Structure
• Data Structure can be classified into two categories:
i) Primitive data structure
ii) Non-Primitive data structure
A. Primitive Data Type
• Primitive data types are the data types available in most of the
programming languages.
• These data types are used to represent single value.
• It is a basic data type available in most of the programming language.

Data type Description

Integer Used to represent a number without decimal point.
Float Used to represent a number with decimal point.
Character Used to represent single character.
Boolean Used to represent logical values either true or false.
B. Non-Primitive Data Type
• Data type derived from primary data types are known as Non-Primitive data
types.
• Non-Primitive data types are used to store group of values.
• It can be divided into two types:
1. Linear Data Structure
• Linear data structure traverses the data elements sequentially.
• In linear data structure, only one data element can directly be reached.
• It includes array, linked list, stack and queues.
Types Description
Arrays Array is a collection of elements. It is used in mathematical
problems like algebra etc. each element of an array is referenced by a
subscripted variable called subscript or index enclosed in parenthesis.
Linked list Linked list is a collection of data elements. It consists of two
parts: Info and Link gives information and Link is an address of next
node. Linked list can be implemented by using pointers.
Stack Stack is a list of elements. In stack, an element may be
inserted or deleted at on which is known as Top of the stack. It performs
two operations: Push and Pop. Push means adding an element in stack
and Pop means removing an element in stack also called Last-in-First-out
(LIFO).
Queue Queue is a linear list of element. In queue, elements are added
at one end called and the existing elements are deleted from other end
called front. It is also called First-in-First-out (FIFO).
2. Non-Linear Data Structure
• Non-Linear data structure is opposite to linear data structure.
• In non-linear data structure, the data values are not arranged in order and
data item is connected to several other data items.
• It uses memory efficiently. Free contiguous memory is not required for
allocating data items.
• It includes trees and graphs.
Type Description
Tree Tree is a flexible, versatile and powerful non-linear data
structure. It is used to represent data items and the
processing hierarchical relationship between the
grandfather and his children & grandchildren. It is an ideal
data structure for representing hierarchical data.
Graph Graph is a non-linear data structure which consists of a finite
set of ordered pairs called edges. Graph is a set of elements
connected by edges. Each element is called a vertex and
node.
Static Data Structure
• The static data structure is a kind of data structure, in which once
memory space is allocated it cannot extend, i.e. the memory
allocation for the data structure takes place at compile-time that
cannot be changed afterwards.
Example: Array
Dynamic Data Structure
• Dynamic Data Structure is another kind of data structure, which can
be extended or shrink during the execution, i.e., the memory
allocation as well as memory de-allocation for the data structure
takes place at run-time and allocates memory as required amount at
any time.
Example: linked list, stack, queue, tree
Applications of Data Structure
Data Structure is used in various fields of Computer Science, such as:
• Compiler Design
• Operating System
• Database Management System
• Statistical Analysis Package
• Numerical Analysis
• Graphics
• Artificial Intelligence
• Simulation
Abstract Data Types
• Abstract Data type (ADT) is a type (or class) for objects whose
behavior is defined by a set of value and a set of operations.
• only mentions what operations are to be performed but not how
these operations will be implemented.
• does not specify how data will be organized in memory and what
algorithms will be used for implementing the operations.
• called abstract because it gives an implementation independent view.
The process of providing only the essentials and hiding the details is
known as abstraction.
Operations Performed on Data Structure
Operation Description
Creation Allocation of memory for the data structure, the creation of
data structure may take place either during compile-time or
during run-time.
Insertion Insert a data item in the data structure.
Deletion Delete a data item from the data structure.
Traversing Accessing and processing each data item of the data structure
exactly once.
Searching Find the location of the key value within the data structure.
Sorting Arranging all the data items in a data structure either in ascending
or in descending order or in lexicographical order (for Strings).
Merging Combining the data items of two different sorted lists into a single
sorted list.
Algorithm
• step by step procedure to solve a problem
• a well-organized, pre-arranged, and defined computational module that
receives some values or set of values as input and provides a single or set of
values as output
• a finite sequence of instructions/steps, each of which is very elementary
that must be followed to solve a problem
• said to be accurate and truthful only when it provides the exact wanted
output
• is not the complete code or program, it is just the core logic(solution) of a
problem, which can be expressed either as an informal high-level
description as pseudocode or using a flowchart.
• term was coined from algorism by a Persian author, Abu. Jafar Mohammad
bin Musa al-Khowarizmi and holds a special significance in the field of
computer science
All algorithms must satisfy the following criteria:
• Input: inputs (zero or more quantities) are externally supplied.
• Output: The result (at least one quantity) should be produced after
completion of the job to the user.
• Definiteness: The instructions should be unique, concise, clear and
unambiguous.
• Finiteness: The instructions should be relative in nature and should
not be of an infinite type. Should be terminated after a finite number
of steps.
• Effectiveness: Every instruction must be elementary, so that it can be
carried out, in principle, by a person using only pencil and paper.
Repetition of same steps should be avoided. It must be feasible.
Complexity of an Algorithm
• Space Complexity
The space complexity is the amount of space (memory) needed for an
algorithm to solve the problem. An efficient algorithm takes space as small as
possible.
In general, the total space needed
1. Fixed Space Requirement: Includes space for code, space for simple variables,
constants.
2. Variable Space Requirement: Includes space needed by component variables,
structured variable and dynamically allocated space and the recursive stack
space.
• Time Complexity
• The time complexity of a program is the amount of computer time
it needs to run to completion. The time complexity is of two types
such as
Compilation time
• The amount of time taken by the compiler to compile an algorithm. It
does not calculate for the executable statements, it calculates only the
declaration statements and checks for any syntax and semantic errors.
Runtime
• The run time depends on the size of an algorithm. If the number of
instructions in an algorithm is large, then the run time is also large, and if the
number of instructions in an algorithm is small, then the time for executing
the program is also small. The runtime is calculated for executable statements
and not for declaration statements.
There are three types of time complexities, which can be found in the
analysis of an algorithm:
1. Best case time complexity
2. Average case time complexity
3. Worst case time complexity
Best-case time complexity
• a measure of the minimum time that the algorithm will require. For example,
the best case for a simple linear search on a list occurs when the desired
element is the first element of the list.
• takes shortest time to execute, as it causes the algorithms to do the least
amount of work.
Worst-case time complexity
• a measure of the maximum time that the algorithm will require.
• A worst-case estimate is normally computed because it provides an upper
bound for all inputs including the extreme slowest case also. For example, the
worst case for a simple linear search on a list occurs when the desired
element is found at the last position of the list or not on the list.
Average-case time complexity
• a measure of average time of all instances taken by an algorithm. Average
case analysis does not provide the upper bound and sometimes it is difficult
to compute.
• Analyzing the average case behavior algorithm is a little bit complex than the
best case and worst case. Here, we take the probability with a list of data.
• Average case of algorithm should be the average number of steps but since
data can be at any place, so finding exact behavior of algorithm is difficult. As
the volume of data increases, the average case of algorithm behaves like the
worst case of algorithm.
• Choosing the right algorithms (and data structure) will ensure
the program runs fast while also maintaining integrity and
reliability of data.
In consonance with data structure, there are several algorithm
categories, and here are five of them.
• Search Algorithm – used to search for a data item within a data
structure, allowing the person doing the search to input the appropriate
search terms or keywords.
• Sort Algorithm – Sorting, collating and organizing items in an orderly
manner.
• Insert Algorithm – adding a data item in a data structure via insertion.
• Update Algorithm – From time to time, updates to existing data items
must be made
• Delete Algorithm – If there is an algorithm to add or insert VALUE
items in the data structure, then there is definitely going to be one
purposely for deleting or removing an existing data item.
Steps Required to Develop an Algorithm
• Find a method for solving a problem. Every step should be defined in a precise
and in a clear manner. Pseudo code is also used to describe an algorithm.
• Validate the algorithm. Include all the steps in algorithm and should be done
manually by giving the required input, perform the required steps included in
algorithm and should get the required amount of output in a finite amount of
time.
• Implement the algorithm in terms of programming language.
Write an algorithm that will open a locked door.
1. Get a key.
2. Insert the key into the door knob.
3. If the door opens goto step 4 else goto step 1.
4. Come inside.
5. End
Write an algorithm to prepare a cup of coffee.
6. Get a cup.
7. Pour hot water and a table spoon of coffee.
8. Add sugar if needed.
9. Taste.
10. Drink.
11. End
Write an algorithm to cross the street.
Write an algorithm on crossing the street.
1. Look at the traffic light.
2. If traffic light is green, goto step 1.
3. If traffic light is red, cross the street.
4. End
Write an algorithm on preparing for exam/quiz.
Example
Problem − Design an algorithm to add two numbers and display
the result.
Step 1 − START
Step 2 − declare three integers a, b & c
Step 3 − define values of a & b
Step 4 − add values of a & b
Step 5 − store output of step 4 to c
Step 6 − print c
Step 7 − STOP
Algorithms tell the programmers how to code the program.
Alternatively, the algorithm can be written as −
Step 1 − START
Step 2 − get values of a & b
Step 3 − c ← a + b
Step 4 − display c
Step 5 − STOP
In design and analysis of algorithms, usually the second method
is used to describe an algorithm. It makes it easy for the analyst
to analyze the algorithm ignoring all unwanted definitions. He
can observe what operations are being used and how the
process is flowing.
Writing step numbers, is optional.
Another alternative algorithm to the problem.
Step 1: Start
Step 2: Declare variables num1, num2 and sum.
Step 3: Read values num1 and num2.
Step 4: Add num1 and num2 and assign the result to sum.
sum←num1+num2
Step 5: Display sum
Step 6: Stop
----------------------------------------------------------
1. Input num1,num2
2. sum=num1+num2 add num1 and num2 giving sum
3. Print sum
4. end
Write an algorithm to input two numbers and output the larger
number.
1. Input num1,num2
2. If num1>num2 output num1 else output num2
3. End

Write an algo to input three numbers and output the largest.

1. Input num1,num2
2. Sum=num1+num2
3. Print sum
4. End
Write an algorithm that will input three numbers and output the
largest.
5. Input num1,num2,num3
6. If num1>=num2 and num1>=num3 output num1, goto step 5
7. If num2>=num1 and num2>=num3 output num2, goto step 5
8. If num3>=num1 and num3>=num2 output num3, goto step 5
9. End
We design an algorithm to get a solution of a given problem. A problem
can be solved in more than one way.
Algo to input two numbers and print the larger number.
1. Input fnum
2. Input snum
3. If fnum>snum output fnum else output snum.
4. End
Write an algorithm to input 5 numbers and output how many are positive
and how many are negative.
1. Input num1,num2,num3,num4,num5
2. Pos=0,neg=0
3. If num1>0 pos=pos+1 else neg=neg+1 pos=1
4. If num2>0 pos=pos+1 else neg=neg+1 neg=1
5. If num3>0 pos=pos+1 else neg=neg+1 neg=2
6. If num4>0 pos=pos+1 else neg=neg+1 pos=2
7. If num5>0 pos=pos+1 else neg=neg+1 pos=3
8. Print pos,neg
9. End
Num1=8 num2=-2 num3=-9 num4=7 num5=6
Algorithm to input three numbers and output the largest.
1. Input fnum fnum snum tnum temp
2. Input snum 1 5 9 5
3. Input tnum
4. If fnum>=snum, temp=fnum else temp=snum.
5. If temp>=tnum, output temp else output tnum.
6. End
• 1. r=0, b=0,w=0,total=0
• 2. Pick a marble, total=total+1
• 3. If marble is red then r=r+1
• 4. If marble is blue then b=b+1
• 5. If marble is white then w=w+1
• 6. if total=100 then print r,b,w, goto step 7 else goto step 2
• 7. end
• Write an algo. to input 5 numbers print how many are odd and even.
% modulo integer operator,
5%2=1 5%-2= 1 -5%2= -1 -5%-2=-1 6%2=0
2%2=0
5\2=2 \ - integer division
2\2=1
5/2=2.5 / - real division
2/2=1.0
2%5=2 1%5=1 6%7=6 99%1000=99
Write an algo. to input 5 numbers print how many are odd and even.
Input 5 numbers and output how many are odd and how many are even
1. Input num1,num2,num3,num4,num5
2. odd=0,even=0
3. If num1%2=0 even=even+1 else odd=odd+1
4. If num2%2=0 even=even+1 else odd=odd+1
5. If num3%2=0 even=even+1 else odd=odd+1
6. If num4%2=0 even=even+1 else odd=odd+1
7. If num5%2=0 even=even+1 else odd=odd+1
8. Output odd,even
9. End

5%2=1
2%2=0
a=5 a b c
b=6
c=7
a=a+b
b=b+a
c=a+c
b=b+a
a=a+1
b=b+1
print a,b,c
x=1 x y z
y=2
z=3
x=x+y
y=y+z
z=z+y
x=x+z
x=x-y
y=y%x
print x,y,z
x=1 x y z
y=2
z=3 or if one of them true, true
x=x+y - and if one of them false, false
y=y+z not t=f not f=t
z=z+x
If x>y or y>z print x
x=x-y
y=y-z
If x%2=0 print x else print y
x=1 x y z
y=2
z=3
x=x+y
z=x+y
y=x+y
z=x
while x>y x=x-1
if x>y print x else print y
y=x
x=z
print x,y,z
x=-1 x y z
y=-2 -1 -2 -3
z=-3
x=x+3
y=y+x
z=x+y
x=x%5
if x%5=0 print x else print y
if y>z print y else print z
x=x+1
y=y+z
print x,y,z
x=1 x y z
y=2 1 2 3
z=3
x=x*2
y=y+x
z=x+y
x=x+z
if x>y and x>z print x else print y
y=z
if x=z print x else print z
while x>z x=x-1
print x
• Write an algorithm to input two numbers and swap the two numbers.
• A=5 Output:
• B=6 A=5
• After swap B=6
• A=6 AFTER SWAPPING
• B=5 A=6
B=5
• 1. Input a,b a b c
• 2. print “a= “, a 5 6 5
• 3. print “b= “, b 6 5
• 4. print “after swapping….”
• 5. c=a
• 6. a=b a=5
• 7. b=c b=6
• 8. print “a= “, a after swapping…
• 9. print “b= “, b a=6
• b=5
1. Input a,b a b
2. print “a= “, a 5 6
3. print “b= “, b 11 5
4. print “after swapping….” 6
5. a=a+b
6. b=a-b a=5
7. a=a-b b=6
8. Print “a= “,a after swapping
9. Print “b= “,b a=6
b=5
Write an algorithm that will input 4 digit number and output each digit
by row. Clue: use % and \
Example: 3412 5/3=1.6666….
Output: 5\3=1
3 5%3=2
4
1 1. input n
2 2. print n\1000 -3
Example:1998 3. print n%1000\100 -4
1 4. print n%1000%100\10 -1
9 5. print n%1000%100%10- 2
9
Give the output: note: top to bottom left to right
a=1 b=2 c=3 a=b+c c=a+b c=c+a b=b+c while b>c c=c+1
If c % 2=0 print c print b b=b+c c=c+a
if b>c print c else print b
print a x=a+b+c print x

a b c
1 2 3
5 14 7 14
28 12 14
13 19
14 5
19 52
• A stack is a basic data structure that can be logically thought as
Stack

linear structure represented by a real physical stack or pile, a

structure where insertion and deletion of items takes place at one
end called top of the stack. The basic concept can be illustrated
by thinking of your data set as a stack of plates or books where
you can only take the top item off the stack in order to remove
things from it. This structure is used all throughout programming.
• The basic implementation of a stack is also called a LIFO (Last In
First Out) to demonstrate the way it accesses data, since as we
will see there are various variations of stack implementations.
• There are basically three operations that can be performed on
stacks . They are 1) inserting an item into a stack (push). 2)
deleting an item from the stack (pop). 3) displaying the contents of
the stack(pip).
Stack Representation
The following diagram depicts a stack and its operations −
A stack can be implemented by means of Array, Structure,
Pointer, and Linked List. Stack can either be a fixed size one or it
may have a sense of dynamic resizing. Here, we are going to
implement stack using arrays, which makes it a fixed size stack
implementation.
Basic Operations
Stack operations may involve initializing the stack, using it and
then de-initializing it. Apart from these basic stuffs, a stack is
used for the following two primary operations −
• push() − Pushing (storing) an element on the stack.
• pop() − Removing (accessing) an element from the stack.
To use a stack efficiently, we need to check the status of stack as
well. For the same purpose, the following functionality is added to
stacks −
• peek() − get the top data element of the stack, without
removing it.
• isFull() − check if stack is full.
• isEmpty() − check if stack is empty.
At all times, we maintain a pointer to the last PUSHed data on the
stack. As this pointer always represents the top of the stack,
hence named top. The top pointer provides top value of the
stack without actually removing it.
peek() in C programming language
int peek() {
return stack[top];
}
isfull() in C
bool isfull() {
if(top == MAXSIZE)
return true;
else
return false;
}
isempty()
Implementation of isempty() function in C programming language
is slightly different. We initialize top at -1, as the index in array
starts from 0. So we check if the top is below zero or -1 to
determine if the stack is empty. Here's the code −
bool isempty() {
if(top == -1)
return true;
else
return false;
}
Push Operation
The process of putting a VALUE data element onto stack is
known as a Push Operation. Push operation involves a series of
steps −
Step 1 − Checks if the stack is full.
Step 2 − If the stack is full, produces an error and exit.
Step 3 − If the stack is not full, increments top to point next
empty space.
Step 4 − Adds data element to the stack location, where top is
pointing.
Step 5 − Returns success.
If the linked list is used to implement the stack, then in step 3, we
need to allocate space dynamically.
void push(int data) {
if(!isFull()) {
top = top + 1;
stack[top] = data;
}
else
{
printf("Could not insert data, Stack is full.\n");
}
}
Pop Operation
Accessing the content while removing it from the stack, is known
as a Pop Operation. In an array implementation of pop()
operation, the data element is not actually removed,
instead top is decremented to a lower position in the stack to
point to the next value. But in linked-list implementation, pop()
actually removes data element and deallocates memory space.
A Pop operation may involve the following steps −
Step 1 − Checks if the stack is empty.
Step 2 − If the stack is empty, produces an error and exit.
Step 3 − If the stack is not empty, accesses the data element at
which top is pointing.
Step 4 − Decreases the value of top by 1.
Step 5 − Returns success.
int pop(int data) {
if(!isempty()) {
data = stack[top];
top = top - 1;
return data;
} else {
printf("Could not retrieve data, Stack is empty.\n");
}
}
Applications of Stacks
The way to write arithmetic expression is known as a notation.
An arithmetic expression can be written in three different but
equivalent notations, i.e., without changing the essence or output
of an expression. These notations are −
• Infix Notation
• Prefix (Polish) Notation
• Postfix (Reverse-Polish) Notation
• A+B
Infix Notation
We write expression in infix notation, e.g. a - b + c, where operators
are used in-between operands. It is easy for us humans to read,
write, and speak in infix notation but the same does not go well with
computing devices. An algorithm to process infix notation could be
difficult and costly in terms of time and space consumption.
Prefix Notation
In this notation, operator is prefixed to operands, i.e. operator is
written ahead of operands. For example, +ab. This is equivalent to its
infix notation a + b. Prefix notation is also known as Polish Notation.
Postfix Notation
This notation style is known as Reversed Polish Notation. In this
notation style, the operator is postfixed to the operands i.e., the
operator is written after the operands. For example, ab+. This is
equivalent to its infix notation a + b.
HIERARCHY OF OPERATORS:
1. PARENTHESIS
2. EXPONENT(^)
3. MODULO ($ OR %) MULTIPLICATION AND DIVISION (*,/)
4. ADDITION AND SUBTRACTION (+,-)
Given: ((A + B) - C)
PREFIX: - + A B C
POSTFIX: A B + C –
Given: (A + (B – C))
PREFIX: + A – B C
POSTFIX: A B C - +
CONVERT INFIX TO PREFIX/POSTIFX
1. FULLY PARENTHESIZE THE EXPRESSION BASED ON HIERARCHY.
2. MOVE THE OPERATOR TO THE CORRESPONDING LEFT/RIGHT
PARENTHESIS.
(A + B)
PREFIX +AB
POSTFIX AB+
ORIGINAL: A+B-C
((A+B)-C)
PREFIX -+ABC
POSTFIX AB+C-

ORIGINAL: A+(B-C)
(A+(B-C))
PREFIX: +A-BC
• POSTFIX: ABC-+
 ((A + B) - C)
-+ABC PREFIX
AB+C- POSTFIX

(A + (B – C))
+A-BC PREFIX
ABC-+ POSTFIX
(A+B)
PREFIX +AB
POSTFIX AB+

((A + B) – C)
PREFIX -+ABC
POSTFIX AB+C-
(A + (B – C))
PREFIX +A-BC
POSTFIX ABC-+
(((A * B) + (C / D)) – E)
PREFIX -+*AB/CDE
POSTFIX AB*CD/+E-
A*B+C/D -E
((((A / B) * C) + (D % E)) – F)
PREFIX -+*/ABC%DEF

POSTFIX AB/C*DE%+F-
((A-((B*C)/D))+E)
PREFIX +-A/*BCDE
POSTFIX ABC*D/-E+

((((A / B) * C) + (D % E)) –F)

PREFIX -+*/ABC%DEF
POSTFIX AB/C*DE%+F-
((A – ((B * C) / D)) + E)
PREFIX: + - A / * B C D E
POSTFIX: A B C * D / - E +

((((A / B) * C) + (D % E)) –F) P(EM)(MD)(AS)

PREFIX:
-+*/ ABC%DEF
POSTFIX:
AB/C*DE%+F-
((A – ((B / C) % D)) – (E ^ (F+G)))
PREFIX --A%/BCD^E+FG

POSTFIX ABC/D%-EFG+^-
P^Y/T/H-(O+N)
PREFIX: -//^PYTH+ON
POSTFIX:PY^T/H/ON+-
U-(N+I)^V+E*R+S/I/(T-Y)
(((U-((N+I)^V))+(E*R))+((S/I)/(T-Y)))
PREFIX:++-U^+NIV*ER//SI-TY
POSTFIX:UNI+V^-ER*+SI/TY-/+
((((P^Y)/T)/H)-(O+N))
PREFIX -//^PYTH+ON
POSTFIX PY^T/H/ON+-

(((U-((N+I)^V))+(E*R))+((S/I)/(T-Y)))
PREFIX ++-U^+NIV*ER//SI-TY
POSTFIX UNI+V^-ER*+SI/TY-/+
A/B/C*D*E*F+G+H+I
((((((((A/B)/C)*D)*E)*F)+G)+H)+I)
PREFIX:+++***//ABCDEFGHI
P*O-(L+Y)-T+E*C/H+(N-I)^C
(((((P*O)-(L+Y))-T)+((E*C)/H))+((N-I)^C))
P*O-(L+Y)-T+E*C/H+(N-I)^C
POSTFIX:PO*LY+-T-EC*H/+NI-C^+
((((((((A/B)/C)*D)*E)*F)+G)+H)+I)
PREFIX +++***//ABCDEFGHI
POSTFIX AB/C/D*E*F*G+H+I+

(((((P*O)-(L+Y))-T)+((E*C)/H))+((N-I)^C))
PREFIX ++--*PO+LYT/*ECH^-NIC
POSTFIX PO*LY+-T-EC*H/+NI-C^+
A-B/C%D-E^(F+G)
((A-(B/(C$D)))-(E^(F+G)))
PREFIX:--A/B$CD^E+FG
POSTFIX:ABCD$/-EFG+^-

H*A/T-(R+E)/D
(((H*A)/T)-((R+E)/D))
PREFIX:-/*HAT/+RED
POSTFIX:HA*T/RE+D/-
(((A+B)+C)-((D-E)^F))
PREFIX -++ABC^-DEF
POSTFIX AB+C+DE-F^-

((((P * U)+ ((P / I) * A)) – N) – S)

PREFIX --+*PU*/PIANS
POSTFIX PU*PI/A*+N-S-
((((A / B)* C) + (D % E))–F)
PREFIX OUTPUT STRING STACK
FED%CBA/*+-

REVERSE: )F-))E%D(+)C*)B/A((((

-+*/ABC%DEF
-+*/ABC%DEF