INFO0902 Data Structures and Algorithms

Transcription

1 INFO0902 Data Structures and Algorithms Basic ADTs: stacks, queues, array lists, node list, sequences, iterators Justus H. Piater

2 Stacks

3 The Stack ADT (stack, LIFO) void push(object e); Object pop(void); Integer size(void); Boolean isempty(void); Object top(void); Applications? Stacks 3 / 83

4 Java Interface /** * Interface for a stack: a collection of objects that are inserted * and removed according to the last in first out principle. * Roberto Tamassia Michael Goodrich EmptyStackException */ public interface Stack { /** * Return the number of elements in the stack. number of elements in the stack. */ public int size(); /** * Return whether the stack is empty. true if the stack is empty, false otherwise. */ Stacks 4 / 83

5 Java Interface (Continued) public boolean isempty(); /** * Inspect the element at the top of the stack. top element in the stack. EmptyStackException if the stack is empty. */ public Object top() throws EmptyStackException; /** * Insert an element at the top of the stack. element element to be inserted. */ public void push (Object element); /** * Remove the top element from the stack. element removed. EmptyStackException if the stack is empty. */ public Object pop() throws EmptyStackException; Stacks 5 / 83

6 Errors pop() and top() raise an error if the stack is empty: /** * Runtime exception thrown when one tries to perform operation top or * pop on an empty stack. */ public class EmptyStackException extends RuntimeException { public EmptyStackException(String err) { super(err); Stacks 6 / 83

7 Implementation: Array Algorithm size(): return Algorithm isempty(): return Algorithm top(): if isempty() then error return Algorithm push( ): if size() then error Algorithm pop(): if isempty() then Stacks 7 / 83

8 Implementation: Array (Continued) error return Stacks 8 / 83

9 Complexity Time: Space: Stacks 9 / 83

10 Java Implementation /** * Implementation of the Stack interface using a fixed length array. * An exception is thrown if a push operation is attempted when the * size of the stack is equal to the length of the array. * Natasha Gelfand Roberto Tamassia FullStackException */ public class ArrayStack implements Stack { /** * Default length of the array used to implement the stack. */ public static final int CAPACITY = 1000; /** * Length of the array used to implement the stack. */ protected int capacity; Stacks 10 / 83

11 Java Implementation (Continued) /** * Array used to implement the stack. */ protected Object stack[]; /** * Index of the top element of the stack in the array. */ protected int top = 1; /** * Initialize the stack to use an array of default length CAPACITY. */ public ArrayStack() { this(capacity); /** * Initialize the stack to use an array of given length. * cap length of the array. */ Stacks 11 / 83

12 Java Implementation (Continued) public ArrayStack(int cap) { capacity = cap; stack = new Object[capacity]; /** * O(1) time. */ public int size() { return (top + 1); /** * O(1) time. */ public boolean isempty() { return (top < 0); /** * O(1) time. FullStackException if the array is full. Stacks 12 / 83

13 Java Implementation (Continued) */ public void push(object obj) throws FullStackException { if (size() == capacity) throw new FullStackException("Stack overflow."); stack[++top] = obj; /** * O(1) time. */ public Object top() throws EmptyStackException { if (isempty()) throw new EmptyStackException("Stack is empty."); return stack[top]; /** * O(1) time. */ public Object pop() throws EmptyStackException { Object elem; Stacks 13 / 83

14 Java Implementation (Continued) if (isempty()) throw new EmptyStackException("Stack is Empty."); elem = stack[top]; stack[top ] = null; // dereference stack[top] for garbage collection. return elem; Stacks 14 / 83

15 Application: Reverse an Array public static Integer[] reverse(integer[] a) { Stack stack = new ArrayStack(a.length); Integer[] b = new Integer[a.length]; for (int i=0; i < a.length; i++) stack.push(a[i]); for (int i=0; i < a.length; i++) b[i] = (Integer) (stack.pop()); return b; Stacks 15 / 83

16 Application: Matching Parentheses Algorithm parenmatch(, ): Input: a string of parentheses of different types. Output: true if all the parentheses match, false otherwise. empty stack for to do if is a left parenthesis then.push( ) else if.isempty() then return false if.pop() does not match return false if.isempty() then return true else return false then Stacks 16 / 83

17 Queues

18 The Queue ADT (file, FIFO) void enqueue(object e); Object dequeue(void); Integer size(void); Boolean isempty(void); Object front(void); Applications? Queues 18 / 83

19 Java Interface public interface Queue { /** * Returns the number of elements in the queue. number of elements in the queue. */ public int size(); /** * Returns whether the queue is empty. true if the queue is empty, false otherwise. */ public boolean isempty(); /** * Inspects the element at the front of the queue. element at the front of the queue. EmptyQueueException if the queue is empty. */ public Object front() throws EmptyQueueException; /** * Inserts an element at the rear of the queue. Queues 19 / 83

20 Java Interface (Continued) element new element to be inserted. */ public void enqueue (Object element); /** * Removes the element at the front of the queue. element removed. EmptyQueueException if the queue is empty. */ public Object dequeue() throws EmptyQueueException; Queues 20 / 83

21 Implementation: Simple Array Queues 21 / 83

22 Implementation: Circular Array Algorithm size(): return mod Algorithm isempty(): return Algorithm front(): if isempty() then error return Algorithm dequeue(): if isempty() then error return mod Algorithm enqueue(o): Queues 22 / 83

23 if size() then error mod Implementation: Circular Array (Continued) Queues 23 / 83

24 Complexity Time: Space: Queues 24 / 83

25 Linked Lists

26 Linked List DS Useful to avoid arbitrary capacity limits. The list is identified by the head pointer. Each node contains the element and next pointers. A null next pointer indicates the end of the list. Linked Lists 26 / 83

27 A Node in Java 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 getelement() { return element; public Node getnext() { return next; Linked Lists 27 / 83

28 A Node in Java (Continued) // Modifier methods: public void setelement(object newelem) { element = newelem; public void setnext(node newnext) { next = newnext; Linked Lists 28 / 83

29 Complexity Space: Insertion and removal at the head: Insertion and removal at the tail: Ditto, with additional tail pointer: Linked Lists 29 / 83

30 Implementing a Stack Complexity of the operations? public class NodeStack implements Stack { protected Node top; // reference to the head node protected int size; // number of elements in the stack public NodeStack() { // constructs an empty stack top = null; size = 0; public int size() { return size; public boolean isempty() { if (top == null) return true; return false; public void push(object elem) { Node v = new Node(elem, top); // create and link in a new node Linked Lists 30 / 83

31 Implementing a Stack (Continued) top = v; size++; public Object top() throws EmptyStackException { if (isempty()) throw new EmptyStackException("Stack is empty."); return top.getelement(); public Object pop() throws EmptyStackException { if (isempty()) throw new EmptyStackException("Stack is empty."); Object temp = top.getelement(); top = top.getnext(); // link out the former top node size ; return temp; Linked Lists 31 / 83

32 Implementing a Queue Complexity of the operations? Why not the other way around? public void enqueue(object obj) { Node node = new Node(); node.setelement(obj); node.setnext(null); // node will be new tail node if (size == 0) head = node; // special case of a previously empty queue else tail.setnext(node); // add node at the tail of the list tail = node; // update the reference to the tail node size++; public Object dequeue() throws EmptyQueueException { if (size == 0) throw new EmptyQueueException("Queue is empty."); Object obj = head.getelement(); Linked Lists 32 / 83

33 Implementing a Queue (Continued) head = head.getnext(); size ; if (size == 0) tail = null; // the queue is now empty return obj; Linked Lists 33 / 83

34 Deques

35 The Deque ADT (double-ended queue) void insertfirst(object e); void insertlast(object e); Object removefirst(void); Object removelast(void); Integer size(void); Boolean isempty(void); Object first(void); Object last(void); Generalization of both the stack and the queue. Deques 35 / 83

36 Applications? The Deque ADT (double-ended queue) (Continued) Deques 36 / 83

37 Doubly Linked List DS public class DLNode { private Object element; private DLNode next, prev; DLNode() { this(null, null, null); DLNode(Object e, DLNode p, DLNode n) { element = e; next = n; prev = p; public void setelement(object newelem) { element = newelem; public void setnext(dlnode newnext) { next = newnext; public void setprev(dlnode newprev) { prev = newprev; public Object getelement() { return element; public DLNode getnext() { return next; public DLNode getprev() { return prev; Deques 37 / 83

38 Sentinel Nodes All insertions and removals are done in the same way, including at the head and at the tail. Deques 38 / 83

39 Implementing a Deque using a Doubly Linked List public class NodeDeque implements Deque { protected DLNode header, trailer; // sentinels protected int size; // number of elements public NodeDeque() { // initialize an empty deque header = new DLNode(); trailer = new DLNode(); header.setnext(trailer); // make header point to trailer trailer.setprev(header); // make trailer point to header size = 0; public Object first() throws EmptyDequeException { if (isempty()) throw new EmptyDequeException("Deque is empty."); return header.getnext().getelement(); public void insertfirst(object o) { DLNode second = header.getnext(); DLNode first = new DLNode(o, header, second); second.setprev(first); Deques 39 / 83

40 Implementing a Deque using a Doubly Linked List (Continued) header.setnext(first); size++; public Object removelast() throws EmptyDequeException { if (isempty()) throw new EmptyDequeException("Deque is empty."); DLNode last = trailer.getprev(); Object o = last.getelement(); DLNode secondtolast = last.getprev(); trailer.setprev(secondtolast); secondtolast.setnext(trailer); size ; return o; Deques 40 / 83

41 Array Lists

42 The Array List ADT Abstraction of an array: access by rank,, etc., Object elematrank(integer r); Object replaceatrank(integer r, Object e); void insertatrank(integer r, Object e); Object removeatrank(integer r); Array Lists 42 / 83

43 Java Interface public interface ArrayList { /** Returns the number of elements in the vector. */ public int size(); /** Returns whether the vector is empty. */ public boolean isempty(); /** Returns the element stored at the given rank. */ public Object elematrank(int r) throws BoundaryViolationException; /** Replaces the element stored at the given rank. */ public Object replaceatrank(int r, Object e) throws BoundaryViolationException; /** Inserts an element at the given rank. */ public void insertatrank(int r, Object e) throws BoundaryViolationException; /** Removes the element stored at the given rank. */ public Object removeatrank(int r) throws BoundaryViolationException; Array Lists 43 / 83

44 Implementing a Deque using an Array List Array Lists 44 / 83

45 Implementation by a Fixed-Size Array Complexity of the four functions in terms of : Complexity of the four functions in terms of and : Insertions and removals at in? Array Lists 45 / 83

46 Java Implementation /** Realization of a vector by means of an array. The array has * initial length 16 and is doubled when the size of the vector * exceeds the capacity of the array. No shrinking of the array is * performed. */ public class ArrayVector implements Vector { private Object[] A; // array storing the elements of the vector private int capacity = 16; // initial length of array A private int size = 0; // number of elements stored in the vector /** Creates the vector with initial capacity 16. */ public ArrayVector() { A = new Object[capacity]; /** Inserts an element at the given rank. */ public void insertatrank(int r, Object e) throws BoundaryViolationException { checkrank(r, size() + 1); if (size == capacity) { // an overflow capacity *= 2; Object[] B = new Object[capacity]; for (int i=0; i&ltsize; i++) Array Lists 46 / 83

47 Java Implementation (Continued) B[i] = A[i]; A = B; for (int i=size 1; i>=r; i ) // shift elements up A[i+1] = A[i]; A[r] = e; size++; /** Removes the element stored at the given rank. */ public Object removeatrank(int r) throws BoundaryViolationException { checkrank(r, size()); Object temp = A[r]; for (int i=r; i&ltsize 1; i++) // shift elements down A[i] = A[i+1]; size ; return temp; Array Lists 47 / 83

48 Implementation using an Extensible Array Whenever an insertion would exceed the array capacity, it is replaced by another array of twice the size. Proposition: The total time to insert elements at the end of the array is. Proof (by amortization): Suppose that the th augmentation costs Overcharge each insertion by 2 Euros. These Euros will pay for the augmentation. Euros. Array Lists 48 / 83

49 Implementation using an Additive Extensible Array When an insertion would exceed the array capacity, it is replaced by another array larger by a constant increment. Proposition: The total time to insert elements at the end of the array is. Proof: The insertions give rise to augmentations. Thus, the time required to insert all elements is proportional to Array Lists 49 / 83

50 java.util.arraylist and java.util.vector ADT Array List Java ArrayList and Vector size(), isempty() size(), isempty() elematrank( ) get( ) replaceatrank(, ) set(, ) insertatrank(, ) add(, ) removeatrank( ) remove( ) Array Lists 50 / 83

51 Node Lists

52 The Node List ADT Abstraction of a list: access by position; notions of preceding and following elements (but no absolute ranks) Position: Object element(void); Node List: Position first(void); Position last(void); Position prev(position p); Position next(position p); Node Lists 52 / 83

53 The Node List ADT (Continued) Object replace(position p, Object e); Position insertfirst(object e); Position insertlast(object e); Position insertbefore(position p, Object e); Position insertafter(position p, Object e); Object remove(position p); Applications? Node Lists 53 / 83

54 Error Conditions null has been removed from the list belongs to a different list is the first position, and we call prev( ) is the last position, and we call next( ) Which error checks would you perform? Node Lists 54 / 83

55 Java Interface public interface Position { /** Returns the element stored at this position. */ Object element(); public interface PositionList { /** Returns the number of elements in this list. */ public int size(); /** Returns whether the list is empty. */ public boolean isempty(); /** Returns the first node in the list. */ public Position first(); /** Returns the last node in the list. */ public Position last(); /** Returns the node after a given node in the list. */ public Position next(position p) throws InvalidPositionException, BoundaryViolationException; /** Returns the node before a given node in the list. */ public Position prev(position p) throws InvalidPositionException, BoundaryViolationException; Node Lists 55 / 83

56 Java Interface (Continued) /** Inserts an element at the front of the list. */ public Position insertfirst(object e); /** Inserts and element at the back of the list. */ public Position insertlast(object e); /** Inserts an element after the given node in the list. */ public Position insertafter(position p, Object e) throws InvalidPositionException; /** Inserts an element before the given node in the list. */ public Position insertbefore(position p, Object e) throws InvalidPositionException; /** Removes a node from the list. */ public Object remove(position p) throws InvalidPositionException; /** Replaces the element stored at the given node. */ public Object replace(position p, Object e) throws InvalidPositionException; Node Lists 56 / 83

57 Doubly Linked List: insert and remove an element Algorithm insertafter(, ): create a new node.setelement( ).setprev( ).setnext(.getnext()).getnext().setprev( ).setnext( ) return Algorithm remove( ):.getprev().setnext(.getnext()).getnext().setprev(.getprev()) return.element Node Lists 57 / 83

58 Java Implementation: DNode public class DNode implements Position { private DNode prev, next; // References to the nodes before and after private Object element; // Element stored in this position // Constructor public DNode(DNode newprev, DNode newnext, Object elem) { prev = newprev; next = newnext; element = elem; // Method from interface Position public Object element() throws InvalidPositionException { if ((prev == null) && (next == null)) throw new InvalidPositionException("Position is not in a list!"); return element; // Accessor methods public DNode getnext() { return next; public DNode getprev() { return prev; // Update methods Node Lists 58 / 83

59 Java Implementation: DNode (Continued) public void setnext(dnode newnext) { next = newnext; public void setprev(dnode newprev) { prev = newprev; public void setelement(object newelement) { element = newelement; Node Lists 59 / 83

60 Java Implementation: Doubly-Linked List public class NodePositionList implements PositionList { protected int numelts; // Number of elements in the list protected DNode header, trailer; // Special sentinels /** Constructor that creates an empty list; O(1) time */ public NodeList() { numelts = 0; header = new DNode(null, null, null); // create header trailer = new DNode(header, null, null); // create trailer header.setnext(trailer); // make header and trailer point to each other /** Checks if position is valid for this list and converts it to * DNode if it is valid; O(1) time */ protected DNode checkposition(position p) throws InvalidPositionExceptio if (p == null) throw new InvalidPositionException ("Null position passed to NodeList"); if (p == header) throw new InvalidPositionException ("The header node is not a valid position"); Node Lists 60 / 83

61 Java Implementation: Doubly-Linked List (Continued) if (p == trailer) throw new InvalidPositionException ("The trailer node is not a valid position"); try { DNode temp = (DNode)p; if ((temp.getprev() == null) (temp.getnext() == null)) throw new InvalidPositionException ("Position does not belong to a valid NodeList"); return temp; catch (ClassCastException e) { throw new InvalidPositionException ("Position is of wrong type for this list"); /** Returns the number of elements in the list; O(1) time */ public int size() { return numelts; /** Returns whether the list is empty; O(1) time */ public boolean isempty() { return (numelts == 0); /** Returns the first position in the list; O(1) time */ Node Lists 61 / 83

62 Java Implementation: Doubly-Linked List (Continued) public Position first() throws EmptyListException { if (isempty()) throw new EmptyListException("List is empty"); return header.getnext(); /** Returns the position before the given one; O(1) time */ public Position prev(position p) throws InvalidPositionException, BoundaryViolationException { DNode v = checkposition(p); DNode prev = v.getprev(); if (prev == header) throw new BoundaryViolationException ("Cannot advance past the beginning of the list"); return prev; /** Insert the given element before the given position, returning * the new position; O(1) time */ public Position insertbefore(position p, Object element) Node Lists 62 / 83

63 Java Implementation: Doubly-Linked List (Continued) throws InvalidPositionException { // DNode v = checkposition(p); numelts++; DNode newnode = new DNode(v.getPrev(), v, element); v.getprev().setnext(newnode); v.setprev(newnode); return newnode; /** Insert the given element at the beginning of the list, returning * the new position; O(1) time */ public Position insertfirst(object element) { numelts++; DNode newnode = new DNode(header, header.getnext(), element); header.getnext().setprev(newnode); header.setnext(newnode); return newnode; /**Remove the given position from the list; O(1) time */ public Object remove(position p) Node Lists 63 / 83

64 Java Implementation: Doubly-Linked List (Continued) throws InvalidPositionException { DNode v = checkposition(p); numelts ; DNode vprev = v.getprev(); DNode vnext = v.getnext(); vprev.setnext(vnext); vnext.setprev(vprev); Object velem = v.element(); // unlink the position from the list and make it invalid v.setnext(null); v.setprev(null); return velem; /** Replace the element at the given position with the new element * and return the old element; O(1) time */ public Object replace(position p, Object element) throws InvalidPositionException { DNode v = checkposition(p); Node Lists 64 / 83

65 Java Implementation: Doubly-Linked List (Continued) Object oldelt = v.element(); v.setelement(element); return oldelt; Node Lists 65 / 83

66 Sequences

67 The Sequence ADT Union of array list and node list, plus the following bridge functions: Position atrank(integer r); Integer rankof(position p); Sequences 67 / 83

68 Java Interface /** * An interface for a sequence, a data structure supporting all * operations of a vector and a list. */ public interface Sequence extends List, Vector { /** Returns the position containing the element at the given rank. */ public Position atrank(int r) throws BoundaryViolationException; /** Returns the rank of the element stored at the given position. */ public int rankof(position p) throws InvalidPositionException; Sequences 68 / 83

69 Implementation using a Doubly-Linked List Complexity of the array list, node list and bridge functions? Sequences 69 / 83

70 Java Implementation /** Implementation of a sequence by means of a doubly linked list. */ public class NodeSequence extends NodeList implements Sequence { /** Checks whether the given rank is in the range [0, n 1] */ protected void checkrank(int r, int n) throws BoundaryViolationException { if (r < 0 r >= n) throw new BoundaryViolationException("Illegal rank: " + r); /** Returns the position containing the element at the given rank; * O(n) time. */ public Position atrank (int rank) { DNode node; checkrank(rank, size()); if (rank <= size()/2) { // scan forward from the head node = header.getnext(); for (int i=0; i < rank; i++) node = node.getnext(); else { // scan backward from the tail node = trailer.getprev(); Sequences 70 / 83

71 Java Implementation (Continued) for (int i=1; i < size() rank; i++) node = node.getprev(); return node; /** Inserts an element at the given rank; O(n) time. */ public void insertatrank (int rank, Object element) throws BoundaryViolationException { checkrank(rank, size() + 1); if (rank == size()) insertlast(element); else insertbefore(atrank(rank), element); /** Removes the element stored at the given rank; O(n) time. */ public Object removeatrank (int rank) throws BoundaryViolationException { checkrank(rank, size()); return remove(atrank(rank)); Sequences 71 / 83

72 Implementation using an Array Note We need to implement the Position ADT. Complexity of the array list, node list and bridge functions? Sequences 72 / 83

73 Example: The Favorite List ADT Store in a list the elements accessed and their access counts void access(object e); Object remove(object e); List top(integer k); Sequences 73 / 83

74 Two Implementations Sorted list Move-to-front heuristic Complexity of the three functions in the following scenario: 1. accesses of element 1 2. accesses of element accesses of element Sequences 74 / 83

75 Iterators

76 The Iterator ADT To traverse all elements of a collection, independently of its implementation Boolean hasnext(void); Object next(void); Such a collection must provide the following function: Iterator elements(void); Iterators 76 / 83

77 Usage in Java public static void printcontainer(iterable container) { for (java.util.iterator iter = contaner.iterator(); iter.hasnext(); System.out.println(iter.next()); public static void printcontainer(iterable container) { for (Object obj : container) System.out.println(obj); Iterators 77 / 83

78 Position Iterator For node lists and sequences, it can be useful to iterate over positions. next() returns a Position instead of an Object. To obtain a position iterator, use positions() instead of elements(). Iterators 78 / 83

79 Implementing a Position Iterator for the NodePositionList class public class PositionIterator implements Iterator { protected List list; // the underlying list protected Position cur; // the current (next) position public PositionIterator() { // default constructor public PositionIterator(List L) { // preferred constructor list = L; if (list.isempty()) cur = null; // list is empty else cur = list.first(); // start with the first position public boolean hasnext() { return (cur!= null); public Object next() throws NoSuchElementException { if (!hasnext()) throw new NoSuchElementException("No next position"); Position toreturn = cur; if (cur == list.last()) cur = null; // no positions left else cur = list.next(cur); // move cursor to the next position return toreturn; Iterators 79 / 83

80 And Finally To the NodePositionList class we need to add: /** Returns an iterator of all the nodes in the list. */ public Iterator positions() { return new PositionIterator(this); /** Returns an iterator of all the elements in the list. */ public Iterator elements() { return new ElementIterator(this); Iterators 80 / 83

81 Iterators in Java See java.util.iterator. (There is also an older java.util.enumeration, whose use is discouraged.) The Java collections do not expose positions, but the java.util.listiterator provides equivalent functionality. Iterators 81 / 83

82 Summary

83 Summary We recalled some fundamental algorithmic concepts: ADT: stack + queue = deque array list + node list = sequence DS: simple and circular arrays extensible arrays singly and doubly linked lists Design Patterns: adapter iterator Summary 83 / 83