Loading in 5 sec....

CSE 246 Data Structures and AlgorithmsPowerPoint Presentation

CSE 246 Data Structures and Algorithms

- 82 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about ' CSE 246 Data Structures and Algorithms' - jenaya

**An Image/Link below is provided (as is) to download presentation**

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 - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

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 *, /
- Addition/subtraction +, -

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

+ 3 Addition

4 3, 4 Push operand

* 12 Multiplication

3 12,3 Push operand

+ 15 Addition

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)

add symb in postfix string

else {

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

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

}

}

while(!empty(opstk)) {

topsymb=pop(opstk);

add topsymb to postfix string;

}

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

Download Presentation

Connecting to Server..