Lecture2
Upcoming SlideShare
Loading in...5
×
 

Lecture2

on

  • 738 views

 

Statistics

Views

Total Views
738
Views on SlideShare
738
Embed Views
0

Actions

Likes
2
Downloads
19
Comments
0

0 Embeds 0

No embeds

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Lecture2 Lecture2 Presentation Transcript

  • Part-B1 Stacks
  • Abstract Data Types (ADTs)
    • An abstract data type (ADT) is an abstraction of a data structure
    • An ADT specifies:
      • Data stored
      • Operations on the data
      • Error conditions associated with operations
    • Example: ADT modeling a students record
      • The data stored are
        • Student name, id No., as1, as2,as3, exam
      • The operations supported are
        • int averageAs (as1,as2,as3)
        • Int finalMark (as1, as2,as3, exam) )
      • Error conditions:
        • Calculate the final mark for absent student
  • The Stack ADT (§4.2)
    • The Stack ADT stores arbitrary objects
    • Insertions and deletions follow the last-in first-out scheme
    • Think of a spring-loaded plate dispenser
    • Main stack operations:
      • push (object): inserts an element
      • object pop (): removes and returns the last inserted element
    • Auxiliary stack operations:
      • object top (): returns the last inserted element without removing it
      • integer size (): returns the number of elements stored
      • boolean isEmpty (): indicates whether no elements are stored
    View slide
  • Stack Interface in Java
    • Java interface corresponding to our Stack ADT
    • Requires the definition of class EmptyStackException
    public interface Stack { public int size() ; public boolean isEmpty() ; public Object top() throws EmptyStackException ; public void push(Object o) ; public Object pop() throws EmptyStackException ; } View slide
  • Exceptions
    • Attempting the execution of an operation of ADT may sometimes cause an error condition, called an exception
    • Exceptions are said to be “thrown” by an operation that cannot be executed
    • In the Stack ADT, operations pop and top cannot be performed if the stack is empty
    • Attempting the execution of pop or top on an empty stack throws an EmptyStackException
  • Applications of Stacks
    • Direct applications
      • Undo sequence in a text editor
      • Chain of method calls in the Java Virtual Machine
    • Indirect applications
      • Auxiliary data structure for algorithms
      • Component of other data structures
  • Array-based Stack (Implementation)
    • A simple way of implementing the Stack ADT uses an array
    • We add elements from left to right
    • A variable t keeps track of the index of the top element
    S 0 1 2 t … Algorithm size () return t + 1 Algorithm pop () if isEmpty () then throw EmptyStackException else t  t  1 return S [ t + 1]
  • Array-based Stack (cont.)
    • The array storing the stack elements may become full
    • A push operation will then throw a FullStackException
      • Limitation of the array-based implementation
      • Not intrinsic to the Stack ADT
    Algorithm push ( o ) if t = S.length  1 then throw FullStackException else t  t + 1 S [ t ]  o S 0 1 2 t …
  • Array-based Stack (Cont.)
    • A Stack might be empty
    • top returns the element at the top of the Stack, but does not remove the top element. When the Stack is empty, an error occurs.
    S 0 1 2 t … Algorithm isEmpty() if t<0 then return true else return false Algorithm top () if isEmpty () then throw EmptyStackException return S [ t ]
  • Performance and Limitations for array-based Stack
    • Performance
      • Let n be the number of elements in the stack
      • The space used is O ( n )
      • Each operation runs in time O (1)
    • Limitations
      • The maximum size of the stack must be defined a priori and cannot be changed
      • Trying to push a new element into a full stack causes an implementation-specific exception
  • Array-based Stack in Java public class ArrayStack implements Stack { // holds the stack elements private Object S[ ]; // index to top element private int top = -1; // constructor public ArrayStack(int capacity) { S = new Object[capacity]); }
  • Array-based Stack in Java public Object pop() throws EmptyStackException { if isEmpty() throw new EmptyStackException (“ Empty stack: cannot pop ”); Object temp = S[top]; // facilitates garbage collection S[top] = null ; top = top – 1; return temp; } public int size() { return (top + 1);
  • Array-based Stack in Java public boolean isEmpty() { return (top < 0); } public void push(Object obj) throws FullStackException { if (size() == capacity) throw new FullStackException(&quot;Stack overflow.&quot;); S[++top] = obj; } public Object top() throws EmptyStackException { if (isEmpty()) throw new EmptyStackException(&quot;Stack is empty.&quot;); return S[top]; }
  • Parentheses Matching
    • An expression, i.e.,[(2+3)*x+5]*2.
    • Each “(”, “{”, or “[” must be paired with a matching “)”, “}”, or “[”
      • correct: ( )(( )) { ([( )]) }
      • correct: ((( )(( )) { ([( )]) }
      • incorrect: )(( )) { ([( )]) }
      • incorrect: ( { [ ]) }
      • incorrect: (
  • Parentheses Matching Algorithm
    • Algorithm ParenMatch ( X , n ) :
    • Input: An array X of n tokens, each of which is either a grouping symbol, a
    • variable, an arithmetic operator, or a number
    • Output: true if and only if all the grouping symbols in X match
    • Let S be an empty stack
    • for i = 0 to n - 1 do
    • if X [ i ] is an opening grouping symbol then
    • S . push ( X [ i ] )
    • else if X [ i ] is a closing grouping symbol then
    • if S . isEmpty () then
    • return false { nothing to match with }
    • if S . pop () does not match the type of X [ i ] then
    • return false { wrong type }
    • if S . isEmpty () then
    • return true { every symbol matched }
    • else
    • return false { some symbols were never matched }
  • Parentheses Matching Example 1
    • Input: () (() [()])
    ([ Push [ [ 5 ( Pop ( Test if ( and X[i] match? YES ) 4 (( Push ( ( 3 ( Push ( ( 2 Pop ( Test if ( and X[i] match? YES ) 1 ( Push ( ( 0 Output Stack Operation X[i] i
  • Parentheses Matching Example 1
    • Input: () (() [()])
    Pop ( Test if ( and X[i] match? YES ) 9 TRUE Test if stack is Empty? YES ( Pop [ Test if [ and X[i] match? YES ] 8 ([ Pop ( Test if ( and X[i] match? YES ) 7 ([( Push ( ( 6 Output Stack Operation X[i] i
  • Parentheses Matching Example 2
    • Input: ( () [] ]()
    FASLE Pop ( Test if ( and X[i] match ? NO ] 5 ( Pop [ Test if [ and X[i] match? YES ] 4 ([ Push [ [ 3 ( Pop ( Test if ( and X[i] match? YES ) 2 (( Push ( ( 1 ( Push ( ( 0 Output Stack Operation X[i] i
  • Computing Spans (not in book)
    • We show how to use a stack as an auxiliary data structure in an algorithm
    • Given an array X , the span S [ i ] of X [ i ] is the maximum number of consecutive elements X [ j ] immediately preceding X [ i ] and such that X [ j ]  X [ j+1 ]
    • Spans have applications to financial analysis
      • E.g., stock at 52-week high
    X S 1 3 2 1 1 2 5 4 3 6
  • Quadratic Algorithm Algorithm spans1 ( X, n ) Input array X of n integers Output array S of spans of X # S  new array of n integers n for i  0 to n  1 do n s  1 n while s  i  X [ i  s ]  X [ i -s+1 ] 1  2  …  ( n  1) s  s  1 1  2  …  ( n  1) S [ i ]  s n return S 1 X[]= 1,2,3, …, n-1, n.
    • Algorithm spans1 runs in O ( n 2 ) time
  • Computing Spans with a Stack
    • We push the n elements in the stack
    • We sacn the elements in the stack in the reverse order.
      • We find the last element x[j] with x[j]<=x[i] and x[j-1]>x[i] and set s[i]=i-j+1.
      • If no such a j exists, s[i]=i+1.
    • Compute the s[i] for the remaining i’s as follows:
      • for (i=n-2; i>=0; i--)
      • if (s[i+1]>1 & s[i]==0) then
      • s[i]=s[i+1]-1
  • Example:
    • i= 0, 1, 2, 3, 4, 5, 6, 7
    • X[i]= 6, 3, 4, 1, 2, 3, 5, 4
    • S[i]= 1, 1, 2, 1, 2, 3, 4, 1.
    • 4
    • 5 5
    • 3 3
    • 2 2
    • 1 1
    • 4 4 4
    • 3 3 3
    • 6 6 6 6
    • Stack Stack Stack Stack Stack
  • Linear Algorithm Algorithm spans2 ( X, n ) # S  new array of n integers n A  new empty stack 1 for i  0 to n  1 do A.push(i) n i=n-1 ; j=n-1 ; 1 while (i<=0) do while (  A . isEmpty ()  X [ A.top ()]  X [ j ] ) do n j  A.pop () n if A . isEmpty () then n S [ i ]  i  1 1 else S [ i ]  i  j +1 n i=j-1; n return S 1
    • Each index of the array
      • Is pushed into the stack exactly one
      • Is popped from the stack at most once
    • The statements in the two while loops are executed at most n times
    • Algorithm spans2 runs in O ( n ) time
    • for (i=n-2; i>=0; i--)
      • if (s[i+1]>1 & s[i]==0) then s[i]=s[i+1]-1
  • Summary of Stack
    • Understand the definition of Stack ( basic )
    • Applications
      • Parentheses ( moderate )
      • Computing Spans ( not required )
    • Implementation of Stack is not required.
    • You should be able to use stack to write programs to solve problems
  • Week 3: Tutorial Arrangement
    • Week 3 Tutorial (Feb. 6, 2006, 6:30p.m. – 7:20p.m) will be in MMW2478 (CS lab, second floor, Lift 18, on the left hand side after you go through the tunnel.)
    City Uni. Lift 18 Tunnel connecting city U and Festival Walk
  • Remarks
    • Emphasize the concept of ADT.
    • More examples about ADT
    • Delete the Span application examples.
    • Add Queue part (perhaps to week 3)
    • Teach slowly.