Stacks Goodrich, Tamassia Linked Lists 1
Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: n n n Data stored Operations on the data Error conditions associated with operations Goodrich, Tamassia Example: ADT modeling a simple stock trading system n n The data stored are buy/sell orders The operations supported are w order buy(stock, shares, price) w order sell(stock, shares, price) w void cancel(order) n Error conditions: w Buy/sell a nonexistent stock w Cancel a nonexistent order Linked Lists 2
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: n n push(object): inserts an element object pop(): removes and returns the last inserted element Goodrich, Tamassia Linked Lists Auxiliary stack operations: n n n object top(): returns the last inserted element without removing it integer size(): returns the number of elements stored boolean is. Empty(): indicates whether no elements are stored 3
Stack Interface in Java interface corresponding to our Stack ADT Requires the definition of class Empty. Stack. Except ion Different from the built-in Java class java. util. Stack Goodrich, Tamassia public interface Stack { public int size(); public boolean is. Empty(); public Object top() throws Empty. Stack. Exception; public void push(Object o); public Object pop() throws Empty. Stack. Exception; } Linked Lists 4
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 Goodrich, Tamassia Linked Lists 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 Empty. Stack. Exception 5
Applications of Stacks Direct applications n n n Page-visited history in a Web browser Undo sequence in a text editor Chain of method calls in the Java Virtual Machine Indirect applications n n Auxiliary data structure for algorithms Component of other data structures Goodrich, Tamassia Linked Lists 6
Method Stack in the JVM The Java Virtual Machine (JVM) keeps track of the chain of active methods with a stack When a method is called, the JVM pushes on the stack a frame containing main() { int i = 5; foo(i); } foo(int j) { int k; n Local variables and return value n Program counter, keeping track of k = j+1; the statement being executed bar(k); When a method ends, its frame } is popped from the stack and control is passed to the method bar(int m) { on top of the stack … Allows for recursion } Linked Lists Goodrich, Tamassia bar PC = 1 m=6 foo PC = 3 j=5 k=6 main PC = 2 i=5 7
Array-based Stack A simple way of implementing the Stack ADT uses an array We add elements from left to right A variable keeps track of the index of the top element Algorithm size() return t + 1 Algorithm pop() if is. Empty() then throw Empty. Stack. Exception else t t 1 return S[t + 1] … S 0 1 2 Goodrich, Tamassia t Linked Lists 8
Array-based Stack (cont. ) The array storing the stack elements may become full A push operation will then throw a Full. Stack. Exception n n Algorithm push(o) if t = S. length 1 then throw Full. Stack. Exception else t t+1 Limitation of the array. S[t] o based implementation Not intrinsic to the Stack ADT … S 0 1 2 Goodrich, Tamassia t Linked Lists 9
Performance and Limitations Performance n n n Let n be the number of elements in the stack The space used is O(n) Each operation runs in time O(1) Limitations n n 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 Goodrich, Tamassia Linked Lists 10
Array-based Stack in Java public class Array. Stack implements Stack { // holds the stack elements private Object S[ ]; // index to top element private int top = -1; // constructor public Array. Stack(int capacity) { S = new Object[capacity]); } Goodrich, Tamassia public Object pop() throws Empty. Stack. Exception { if is. Empty() throw new Empty. Stack. Exception (“Empty stack: cannot pop”); Object temp = S[top]; // facilitates garbage collection S[top] = null; top = top – 1; return temp; Linked Lists 11
Parentheses Matching Each “(”, “{”, or “[” must be paired with a matching “)”, “}”, or “[” n n n correct: ( )(( )){([( )])} correct: ((( )){([( )])} incorrect: )(( )){([( )])} incorrect: ({[ ])} incorrect: ( Goodrich, Tamassia Linked Lists 12
Parentheses Matching Algorithm Paren. Match(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. is. Empty() 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. is. Empty() then return true {every symbol matched} else return false {some symbols were never matched} Goodrich, Tamassia Linked Lists 13
HTML Tag Matching For fully-correct HTML, each <name> should pair with a matching </name> <body> <center> <h 1> The Little Boat </h 1> </center> <p> The storm tossed the little boat like a cheap sneaker in an old washing machine. The three drunken fishermen were used to such treatment, of course, but not the tree salesman, who even as a stowaway now felt that he had overpaid for the voyage. </p> <ol> <li> Will the salesman die? </li> <li> What color is the boat? </li> <li> And what about Naomi? </li> </ol> </body> Goodrich, Tamassia The Little Boat The storm tossed the little boat like a cheap sneaker in an old washing machine. The three drunken fishermen were used to such treatment, of course, but not the tree salesman, who even as a stowaway now felt that he had overpaid for the voyage. 1. Will the salesman die? 2. What color is the boat? 3. And what about Naomi? Linked Lists 14
Tag Matching Algorithm Is similar to parentheses matching: import java. util. String. Tokenizer; import datastructures. Stack; import datastructures. Node. Stack; import java. io. *; /** Simpli. ed test of matching tags in an HTML document. */ public class HTML { /** Nested class to store simple HTML tags */ public static class Tag { String name; // The name of this tag boolean opening; // Is true i. this is an opening tag public Tag() { // Default constructor name = ""; opening = false; } public Tag(String nm, boolean op) { // Preferred constructor name = nm; opening = op; } } /** Is this an opening tag? */ public boolean is. Opening() { return opening; } /** Return the name of this tag */ public String get. Name() {return name; } /** Test if every opening tag has a matching closing tag. */ public boolean is. HTMLMatched(Tag[ ] tag) { Stack S = new Node. Stack(); // Stack for matching tags for (int i=0; (i<tag. length) && (tag[i] != null); i++) { if (tag[i]. is. Opening()) S. push(tag[i]. get. Name()); // opening tag; push its name on the stack else { if (S. is. Empty()) // nothing to match return false; if (!((String) S. pop()). equals(tag[i]. get. Name())) // wrong match return false; } } Goodrich, Tamassia } if (S. is. Empty()) return true; // we matched everything return false; // we have some tags that never were matched Linked Lists 15
Tag Matching Algorithm, cont. public final static int CAPACITY = 1000; // Tag array size upper bound /* Parse an HTML document into an array of html tags */ public Tag[ ] parse. HTML(Buffered. Reader r) throws IOException { String line; // a line of text boolean in. Tag = false ; // true iff we are in a tag Tag[ ] tag = new Tag[CAPACITY]; // our tag array (initially all null) int count = 0 ; // tag counter while ((line = r. read. Line()) != null) { // Create a string tokenizer for HTML tags (use < and > as delimiters) String. Tokenizer st = new String. Tokenizer(line, "<> t", true); while (st. has. More. Tokens()) { String token = (String) st. next. Token(); if (token. equals("<")) // opening a new HTML tag in. Tag = true; else if (token. equals(">")) // ending an HTML tag in. Tag = false; else if (in. Tag) { // we have a opening or closing HTML tag if ( (token. length() == 0) | | (token. char. At(0) != ’/’) ) tag[count++] = new Tag(token, true); // opening tag else // ending tag[count++] = new Tag(token. substring(1), false); // skip the } // Note: we ignore anything not in an HTML tag } } return tag; // our array of tags } /** Tester method */ public static void main(String[ ] args) throws IOException { Buffered. Reader stdr; // Standard Input Reader stdr = new Buffered. Reader(new Input. Stream. Reader(System. in)); HTML tag. Checker = new HTML(); if (tag. Checker. is. HTMLMatched(tag. Checker. parse. HTML(stdr))) System. out. println("The input file is a matched HTML document. "); else System. out. println("The input file is not a matched HTML document. "); } } Linked Lists Goodrich, Tamassia 16
Computing Spans (not in book) We show to use a stack as an auxiliary data structure in an algorithm Given an 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[i] Spans have applications to financial analysis n E. g. , stock at 52 -week high Goodrich, Tamassia Linked Lists X S 6 1 3 1 4 2 5 3 2 1 17
Quadratic Algorithm spans 1(X, n) Input array X of n integers Output array S of spans of X S new array of n integers for i 0 to n 1 do s 1 while s i X[i s] X[i] s s+1 S[i] s return S # n n n 1 + 2 + …+ (n 1) n 1 Algorithm spans 1 runs in O(n 2) time Goodrich, Tamassia Linked Lists 18
Computing Spans with a Stack We keep in a stack the indices of the elements visible when “looking back” We scan the array from left to right n n Let i be the current index We pop indices from the stack until we find index j such that X[i] X[j] We set S[i] i j We push x onto the stack Goodrich, Tamassia Linked Lists 19
Linear Algorithm Each index of the array n n Is pushed into the stack exactly one Is popped from the stack at most once The statements in the while-loop are executed at most n times Algorithm spans 2 runs in O(n) time Goodrich, Tamassia Algorithm spans 2(X, n) # S new array of n integers n A new empty stack 1 for i 0 to n 1 do n while ( A. is. Empty() X[A. top()] X[i] ) do n A. pop() n if A. is. Empty() then n S[i] i + 1 n else S[i] i A. top() n A. push(i) n return S 1 Linked Lists 20
Queues Goodrich, Tamassia Linked Lists 21
The Queue ADT (§ 4. 3) The Queue ADT stores arbitrary objects Insertions and deletions follow the first-in first-out scheme Insertions are at the rear of the queue and removals are at the front of the queue Main queue operations: n n enqueue(object): inserts an element at the end of the queue object dequeue(): removes and returns the element at the front of the queue Goodrich, Tamassia Linked Lists Auxiliary queue operations: n n n object front(): returns the element at the front without removing it integer size(): returns the number of elements stored boolean is. Empty(): indicates whether no elements are stored Exceptions n Attempting the execution of dequeue or front on an empty queue throws an Empty. Queue. Exception 22
Queue Example Operation enqueue(5) enqueue(3) dequeue() enqueue(7) dequeue() front() dequeue() is. Empty() enqueue(9) enqueue(7) size() enqueue(3) enqueue(5) dequeue() Goodrich, Tamassia Output – – 5 – 3 7 7 “error” true – – 2 – – 9 Q (5) (5, 3) (3, 7) (7) () (9) (9, 7) (9, 7, 3, 5) (7, 3, 5) Linked Lists 23
Applications of Queues Direct applications n n n Waiting lists, bureaucracy Access to shared resources (e. g. , printer) Multiprogramming Indirect applications n n Auxiliary data structure for algorithms Component of other data structures Goodrich, Tamassia Linked Lists 24
Array-based Queue Use an array of size N in a circular fashion Two variables keep track of the front and rear f index of the front element r index immediately past the rear element Array location r is kept empty normal configuration Q 0 1 2 f r wrapped-around configuration Q 0 1 2 Goodrich, Tamassia r f Linked Lists 25
Queue Operations We use the modulo operator (remainder of division) Algorithm size() return (N f + r) mod N Algorithm is. Empty() return (f = r) Q 0 1 2 f 0 1 2 r r Q Goodrich, Tamassia f Linked Lists 26
Queue Operations (cont. ) Operation enqueue throws an exception if the array is full This exception is implementationdependent Algorithm enqueue(o) if size() = N 1 then throw Full. Queue. Exception else Q[r] o r (r + 1) mod N Q 0 1 2 f 0 1 2 r r Q Goodrich, Tamassia f Linked Lists 27
Queue Operations (cont. ) Operation dequeue throws an exception if the queue is empty This exception is specified in the queue ADT Algorithm dequeue() if is. Empty() then throw Empty. Queue. Exception else o Q[f] f (f + 1) mod N return o Q 0 1 2 f 0 1 2 r r Q Goodrich, Tamassia f Linked Lists 28
Queue Interface in Java interface corresponding to our Queue ADT Requires the definition of class Empty. Queue. Exce ption No corresponding built-in Java class Goodrich, Tamassia public interface Queue { public int size(); public boolean is. Empty(); public Object front() throws Empty. Queue. Exception; public void enqueue(Object o); public Object dequeue() throws Empty. Queue. Exception; Linked Lists 29
Application: Round Robin Schedulers We can implement a round robin scheduler using a queue, Q, by repeatedly performing the following steps: 1. 2. 3. e = Q. dequeue() Service element e Q. enqueue(e) The Queue 1. Deque the next element 2. Service the next element 3. Enqueue the serviced element Shared Service Goodrich, Tamassia Linked Lists 30
Linked Lists Goodrich, Tamassia Linked Lists 31
Singly Linked List (§ 4. 4. 1) A singly linked list is a concrete data structure consisting of a sequence of nodes Each node stores n n next element link to the next node elem A Goodrich, Tamassia B C Linked Lists D 32
The Node Class for List Nodes public class Node { // Instance variables: private Object element; private Node next; /** Creates a node with null references to its element and next node. */ public Node() { this(null, null); } /** Creates a node with the given element and next node. */ public Node(Object e, Node n) { element = e; next = n; } // Accessor methods: public Object get. Element() { return element; } public Node get. Next() { return next; } // Modifier methods: public void set. Element(Object new. Elem) { element = new. Elem; } public void set. Next(Node new. Next) { next = new. Next; } } Goodrich, Tamassia Linked Lists 33
Inserting at the Head 1. Allocate a new node 2. Insert new element 3. Have new node point to old head 4. Update head to point to new node Goodrich, Tamassia Linked Lists 34
Removing at the Head 1. Update head to point to next node in the list 2. Allow garbage collector to reclaim the former first node Goodrich, Tamassia Linked Lists 35
Inserting at the Tail 1. Allocate a new node 2. Insert new element 3. Have new node point to null 4. Have old last node point to new node 5. Update tail to Linked Lists Goodrich, point to new node Tamassia 36
Removing at the Tail Removing at the tail of a singly linked list is not efficient! There is no constant -time way to update the tail to point to the previous node Goodrich, Tamassia Linked Lists 37
Stack with a Singly Linked List We can implement a stack with a singly linked list The top element is stored at the first node of the list The space used is O(n) and each operation of the Stack ADT takes O(1) time nodes t elements Goodrich, Tamassia Linked Lists 38
Queue with a Singly Linked List We can implement a queue with a singly linked list n n The front element is stored at the first node The rear element is stored at the last node The space used is O(n) and each operation of the Queue ADT takes O(1) time r nodes f elements Goodrich, Tamassia Linked Lists 39
Vectors and Array Lists Goodrich, Tamassia Linked Lists 40
The Vector ADT (§ 5. 1) The Vector ADT extends the notion of array by storing a sequence of arbitrary objects An element can be accessed, inserted or removed by specifying its rank (number of elements preceding it) An exception is thrown if an incorrect rank is specified (e. g. , a negative rank) Goodrich, Tamassia Main vector operations: n object elem. At. Rank(integer r): returns the element at rank r without removing it n object replace. At. Rank(integer r, object o): replace the element at rank with o and return the old element n insert. At. Rank(integer r, object o): insert a new element o to have rank r n object remove. At. Rank(integer r): removes and returns the element at rank r Additional operations size() and is. Empty() Linked Lists 41
Applications of Vectors Direct applications n Sorted collection of objects (elementary database) Indirect applications n n Auxiliary data structure for algorithms Component of other data structures Goodrich, Tamassia Linked Lists 42
Array-based Vector Use an array V of size N A variable n keeps track of the size of the vector (number of elements stored) Operation elem. At. Rank(r) is implemented in O(1) time by returning V[r] V 0 1 2 Goodrich, Tamassia n r Linked Lists 43
Insertion In operation insert. At. Rank(r, o), we need to make room for the new element by shifting forward the n r elements V[r], …, V[n 1] In the worst case (r = 0), this takes O(n) time V 0 1 2 r n 0 1 2 o r V V Goodrich, Tamassia Linked Lists n 44
Deletion In operation remove. At. Rank(r), we need to fill the hole left by the removed element by shifting backward the n r 1 elements V[r + 1], …, V[n 1] In the worst case (r = 0), this takes O(n) time V 0 1 2 o r n 0 1 2 r V V Goodrich, Tamassia Linked Lists n 45
Performance In the array based implementation of a Vector n n n The space used by the data structure is O(n) size, is. Empty, elem. At. Rank and replace. At. Rank run in O(1) time insert. At. Rank and remove. At. Rank run in O(n) time If we use the array in a circular fashion, insert. At. Rank(0) and remove. At. Rank(0) run in O(1) time In an insert. At. Rank operation, when the array is full, instead of throwing an exception, we can replace the array with a larger one Goodrich, Tamassia Linked Lists 46
Growable Array-based Vector In a push operation, when Algorithm push(o) the array is full, instead of if t = S. length 1 then throwing an exception, we A new array of can replace the array with size … a larger one for i 0 to t do A[i] S[i] How large should the new S A array be? n n incremental strategy: increase the size by a constant c doubling strategy: double the size Goodrich, Tamassia Linked Lists t t+1 S[t] o 47
Comparison of the Strategies We compare the incremental strategy and the doubling strategy by analyzing the total time T(n) needed to perform a series of n push operations We assume that we start with an empty stack represented by an array of size 1 We call amortized time of a push operation the average time taken by a push over the series of operations, i. e. , T(n)/n Goodrich, Tamassia Linked Lists 48
Incremental Strategy Analysis We replace the array k = n/c times The total time T(n) of a series of n push operations is proportional to n + c + 2 c + 3 c + 4 c + … + kc = n + c(1 + 2 + 3 + … + k) = n + ck(k + 1)/2 Since c is a constant, T(n) is O(n + k 2), i. e. , O(n 2) The amortized time of a push operation is O(n) Goodrich, Tamassia Linked Lists 49
Doubling Strategy Analysis We replace the array k = log 2 n times The total time T(n) of a series of geometric series n push operations is 2 proportional to 4 1 1 n + 1 + 2 + 4 + 8 + …+ 2 k = n + 2 k + 1 1 = 2 n 1 8 T(n) is O(n) The amortized time of a push operation is O(1) Goodrich, Tamassia Linked Lists 50
Lists Goodrich, Tamassia Linked Lists 51
Position ADT (§ 5. 2. 2) The Position ADT models the notion of place within a data structure where a single object is stored It gives a unified view of diverse ways of storing data, such as n n a cell of an array a node of a linked list Just one method: n object element(): returns the element stored at the position Goodrich, Tamassia Linked Lists 52
List ADT (§ 5. 2. 3) The List ADT models a sequence of positions storing arbitrary objects It establishes a before/after relation between positions Generic methods: n Accessor methods: n n Update methods: n n n size(), is. Empty() n Goodrich, Tamassia Linked Lists first(), last() prev(p), next(p) replace(p, e) insert. Before(p, e), insert. After(p, e), insert. First(e), insert. Last(e) remove(p) 53
Doubly Linked List A doubly linked list provides a natural implementation of the List ADT Nodes implement Position and store: n n n element link to the previous node link to the next node prev next elem node Special trailer and header nodes/positions header trailer elements Goodrich, Tamassia Linked Lists 54
Insertion We visualize operation insert. After(p, X), which returns position q p A B C p A q B C X p A Goodrich, Tamassia q B Linked Lists X C 55
Insertion Algorithm insert. After(p, e): Create a new node v v. set. Element(e) v. set. Prev(p) {link v to its predecessor} v. set. Next(p. get. Next()) {link v to its successor} (p. get. Next()). set. Prev(v) {link p’s old successor to v} p. set. Next(v) {link p to its new successor, v} return v {the position for the element e} Goodrich, Tamassia Linked Lists 56
Deletion We visualize remove(p), where p = last() A B C p D A Goodrich, Tamassia B Linked Lists C 57
Deletion Algorithm remove(p): t = p. element {a temporary variable to hold the return value} (p. get. Prev()). set. Next(p. get. Next()) {linking out p} (p. get. Next()). set. Prev(p. get. Prev()) p. set. Prev(null) {invalidating the position p} p. set. Next(null) return t Goodrich, Tamassia Linked Lists 58
Performance In the implementation of the List ADT by means of a doubly linked list n n The space used by a list with n elements is O(n) The space used by each position of the list is O(1) All the operations of the List ADT run in O(1) time Operation element() of the Position ADT runs in O(1) time Goodrich, Tamassia Linked Lists 59
Sequences and Iterators Goodrich, Tamassia Linked Lists 60
Sequence ADT (§ 5. 3) The Sequence ADT is the union of the Vector and List ADTs Elements accessed by n n List-based methods: n Rank, or Position Generic methods: n size(), is. Empty() Vector-based methods: n elem. At. Rank(r), replace. At. Rank(r, o), insert. At. Rank(r, o), remove. At. Rank(r) Goodrich, Tamassia Linked Lists first(), last(), prev(p), next(p), replace(p, o), insert. Before(p, o), insert. After(p, o), insert. First(o), insert. Last(o), remove(p) Bridge methods: n at. Rank(r), rank. Of(p) 61
Applications of Sequences The Sequence ADT is a basic, generalpurpose, data structure for storing an ordered collection of elements Direct applications: n n Generic replacement for stack, queue, vector, or list small database (e. g. , address book) Indirect applications: n Building block of more complex data structures Goodrich, Tamassia Linked Lists 62
Linked List Implementation A doubly linked list provides a reasonable implementation of the Sequence ADT Nodes implement Position and store: n n n element link to the previous node link to the next node Position-based methods run in constant time Rank-based methods require searching from header or trailer while keeping track of ranks; hence, run in linear time Special trailer and header nodes/positions header trailer elements Goodrich, Tamassia Linked Lists 63
Array-based Implementation elements We use a circular array storing positions A position object stores: n n Element Rank Indices f and l keep track of first and last positions 0 1 3 positions S f Goodrich, Tamassia 2 Linked Lists l 64
Sequence Implementations Operation size, is. Empty at. Rank, rank. Of, elem. At. Rank first, last, prev, next Array 1 1 1 List 1 n 1 replace. At. Rank insert. At. Rank, remove. At. Rank insert. First, insert. Last insert. After, insert. Before remove 1 1 n n 1 1 1 Goodrich, Tamassia Linked Lists 65
Iterators (§ 5. 4) An iterator abstracts the process of scanning through a collection of elements Methods of the Object. Iterator ADT: n n object() boolean has. Next() object next. Object() reset() n Object. Iterator elements() Two notions of iterator: Extends the concept of Position by adding a traversal capability Implementation with an array or singly linked list Goodrich, Tamassia An iterator is typically associated with an another data structure We can augment the Stack, Queue, Vector, List and Sequence ADTs with method: Linked Lists n n snapshot: freezes the contents of the data structure at a given time dynamic: follows changes to the data structure 66
Скачать презентацию Stacks Goodrich Tamassia Linked Lists 1 Abstract
7c8770988bad8bbc4eccc6ddd84bfcc0.ppt