# CSE 246 Data Structures and Algorithms - PowerPoint PPT Presentation

1 / 19

CSE 246 Data Structures and Algorithms. Spring2011 Lecture#11. Stack Application. Run time Stack procedures Postfix Calculator Interpret infix with precedence. Stack Application.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

CSE 246 Data Structures and Algorithms

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

## CSE 246Data Structures and Algorithms

Spring2011

Lecture#11

### Stack Application

• Run time Stack procedures

• Postfix Calculator

• Interpret infix with precedence

Quratulain

### Stack Application

• Almost invariably, programs compiled from modern high level languages (even C!) make use of a stack frame for the working memory of each procedure or function invocation.

• When any procedure or function is called, a number of words - the stack frame - is pushed onto a program stack.

Quratulain

### Arithmetic Expression

• Infix, Postfix and Prefix notations are three different but equivalent ways of writing expressions.

Quratulain

### Arithmetic Expressions

Infix Expressions

An expression in which every binary operation appears between its operands

Example:

(i) a+b “+” is a binary operation and a and b are its operands

(ii) (a+b)*c

Prefix Expressions

An expression in which operator comes before its operands

Example:

(i) a+b = +ab

(ii) (a+b)*c = *+abc

(iii) a+(b*c) =+a*bc

Postfix Expressions

An expression in which operator comes after its operands

Example:

(i) a+b = ab+

(ii) (a+b)*c = ab+c*

(iii) a+(b*c) = abc*+

Quratulain

### Arithmetic Expression validate

• Pushing an item on to stack correspond to opening a scope, and popping an item from the stack corresponds to closing a scope.

• When the stack is empty and scope ender encountered, so the parenthesis pattern is invalid.

Quratulain

### Infix notation

• Infix notation: A * ( B + C ) / D

• Infix notation needs extra information to make the order of evaluation of the operators clear: rules built into the language about operator precedence and associativity, and brackets ( ) to allow users to override these rules.

Quratulain

### Postfix notation

• The order of evaluation of operators is always left-to-right, and brackets cannot be used to change this order.

• Operators act on values immediately to the left of them.

• RPN has the advantage of being extremely easy, and therefore fast, for a computer to analyze.

Quratulain

### Postfix

• In the 1920's, Jan Lukasiewicz developed a formal logic system which allowed mathematical expressions to be specified without parentheses by placing the operators before (prefix notation) or after (postfix notation) the operands.

• postfix notation for a calculator keyboard.

• computer scientists realized that RPN or postfix notation was very efficient for computer math.

• As a postfix expression is scanned from left to right, operands are simply placed into a last-in, first-out (LIFO) stack and operators may be immediately applied to the operands at the bottom of the stack.

• Another advantage is consistency between machines.

Quratulain

### Practical implications

• Calculations proceed from left to right

• There are no brackets or parentheses, as they are unnecessary.

• Operands precede operator. They are removed as the operation is evaluated.

• When an operation is made, the result becomes an operand itself (for later operators)

• There is no hidden state. No need to wonder if you hit an operator or not.

Quratulain

### Precedence of Operators

• The five binary operators are: addition, subtraction, multiplication, division and exponentiation.

• The order of precedence is (highest to lowest)

• Exponentiation

• Multiplication/division*, /

### Example

• The calculation: ((1 + 2) * 4) + 3 can be written down like this in RPN:

• The expression is evaluated in the following way (the Stack is displayed after Operation has taken place):

• Input Stack Operation

1 1 Push operand

2 1, 2 Push operand

4 3, 4 Push operand

* 12 Multiplication

3 12,3 Push operand

1 2 + 4 * 3 +

Quratulain

### Infix to Postfix conversion Algorithm

Opstk = the empty stack

while(not end of input) {

symb=next input char;

if (symbol is operand)

else {

while(!empty(opstk)&& prcd(stacktop(opstk), symb)) {

topsymb=pop(opstk); add topsymb to postfix string;

}

}

while(!empty(opstk)) {

topsymb=pop(opstk);

}

Quratulain

### Algorithm for postfix evalution

Opndstk = the emty stack;

While (not end of input)

{

Symb = next input character;

If (symb is an operand)

Push(opndstk,symb);

Else

{

Opnd2=pop(opndstk);

Opnd1=pop(opndstk);

Value = result of applying symb to opnd1 and opnd2;

Push(opndstk, value);

}

}

Return (pop(opndstk));

Quratulain

### A Stack Interface in Java

• The stack data structure is included as a "built-in" class in the java.util package of Java.

• it is instructive to learn how to design and implement a stack "from scratch.“

• Implementing an abstract data type in Java involves two steps

• Define interface

• Define exceptions for any error conditions that can arise.

• Provide a concrete class that implements the methods of the interface associated with that ADT.

Quratulain

### Stack interface

public interface Stack <E> {

public int size();

public booleanisEmpty();

public E top() throws EmptyStackException;

public void push( E element);

public E pop() throws EmptyStackException;

}

Quratulain

Quratulain

Quratulain

Left as homework

Quratulain