Sequences Outline and Required Reading: Sequences ( 5.3) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic

Transcription

1 1 Sequences Outline and Required Reading: Sequences ( 5.3) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic

2 Sequence ADT 2 Sequence ADT union of Vector ADT and List ADT provides both rank- and position- based access, plus bridge methods for converting between them general purpose ADT, suitable for a variety of applications (e.g. generic replacement for stacks queues, lists, vectors) example of multiple inheritance inherits methods from two other super ADTs not has rank 3 to be or not to be or is in the position after rank 1 be is in the position after to

3 Sequence ADT (cont.) 3 Java & Multiple Inheritance Java permits only a very weak form of multiple inheritance only interfaces can have multiple super-classes some other OO languages (C++, Lisp, ) allow classes to have multiple super- classes Sequence ADT Interface interface Sequence extends List, Vector { } /* additional bridging methods */ public Position atrank(int rank) throws BoundaryViolationException; public int rankof(position position) throws BoundaryViolationException;

4 Sequence ADT: Full Interface 4 Generic Methods Vector Methods List Methods Bridge Methods public int size(); public boolean isempty(); public Object elementatrank(int k); public Object replaceatrank(int k, Object e); public void insertatrank(int k, Object e); public Object removeatrank(int k); public Position before(position p); public Position after(position p); public Position insertbefore(position p, Object e); public Position insertafter(position p, Object e); public Position insertfirst(object e); public Position insertlast(object e); public Object remove(position p); public Object replaceelement(position p, Object e); public void swapelements(position a, Position b); public Position atrank(int rank); public int rankof(position position);

5 Sequence ADT: Doubly Linked List Implementation 5 DLL Implementation of Sequence ADT employs Position class already seen in Lists; all List ADT methods run in time; but all Vector ADT methods run in time example: to perform removeatrank(r), we must perform link hopping from one of the ends of the list, until we locate the node with rank r slight optimization of Vector ADT methods can be achieved if we start hopping from the closes end of the sequence: RT(n) = O( min(r+1, n-r+1) ) =! C D M N A L S O

6 Sequence ADT: DLL Implementation (cont.) 6 Bridge Methods in DLL Implementation of Sequence ADT both bridge methods have running time (1) Position AtRank(int rank): start from header; move towards tail, node by node, until rank nodes are passed; return current node C D M N A L S O (2) int rankofposition(position p): start from p; move towards header, node by node, until header encountered; return the number of nodes passed p C D M N A L S O

7 Sequence ADT: DLL Implementation (cont.) 7 Significance of Bridge Methods implementation of Vector ADT in DLL Implementation methods simplified! Implementation of List methods automatically borrowed! public class NodeSequence extends NodeList implements Vector { /* additional bridging methods */ public Position atrank(int rank) throws BoundaryViolationException; public int rankof(position position) throws BoundaryViolationException; } /* Vector methods */ public Object elematrank(int rank) throws { return atrank(rank).element(); } public void insertatrank(int rank, Object element) throws { insertbefore(atrank(rank), element); } public Object removeatrank(int rank) throws { return remove(atrank(rank)); }!

8 Sequence ADT: DLL Implementation (cont.) 8 Run Times Sequence Method size isempty elementatrank insertatrank replaceatrank removeatrank all List methods Time Vector methods slow, since bridge method atrank(k) is slow! Space Usage Good!

9 Sequence ADT: Array-Based Implementation 9 Array-Sequence ADT: store plain elements of S (directly) in an array A; Naïve Approach Positions are defined differently than in case of List ADT and have only auxiliary function class ArrayPosition1 implements Position { } Object[ ] A; /* reference to array A */ index i; /* place in A where corresponding element is stored */ public ArrayPosition1(Object[ ] B, int j) {A=B; i=j;} Object element() {return A[i];} A[ ] to be or not to be i= i=1 i=2 i=3 i=4 i=5 These positions are not stored in ArraySequence! The application must store them elsewhere for later use.

10 Sequence ADT: Array-Based Implementation (cont.) 10 class ArraySequence implements Sequence { } protected Object[ ] S; protected int size; public Object elematrank(int rank) throws { return S[rank]; } public Object replaceatrank(int rank, Object e) throws { Object temp = S[rank]; S[rank]=e; return temp; } public ArrayPosition1 first() throws { ArrayPosition1 temp = new ArrayPosition1(S, 0); return temp; } public ArrayPosition1 last() throws { ArrayPosition1 temp = new ArrayPosition1(S, size); return temp; }

11 Sequence ADT: Array-Based Implementation (cont.) 11 Array-Sequence ADT: insertion of a new element extremely tricky : Problems with Naïve Approach (1) new element/object should be inserted in the underlying array through shifting of elements (2) ranks of all subsequent positions should be increased by one; however, there is no reference from A to Positions!!! new A[ ] to be or maybe not to be i=0 i=1 i=2 i=3 i=3 i=4 i=5 ranks of these positions should be increased by 1

12 Sequence ADT: Array-Based Implementation (cont.) 12 Example 1 [ insertion in case of naïve array-sequence implementation ] Assume: A[ ] to be or not to be Execute: ArrayPosition1 p = myseq.last(); i=5 p Execute Insertion: A[ ] new to be or maybe not to be i=5 p should be updated now. But, how???! Sequence (i.e. A) does not hold any reference back to p!!! p

13 Sequence ADT: Array-Based Implementation (cont.) 13 Array-Sequence ADT: store elements in Positions, store Positions Clever Approach in the array now a reference between A and positions exists no problems with insertion class ArrayPosition2 implements Position { int rank; Object element; public ArrayPosition2(int r, Object o) {rank=r; element=o;} Object element() {return element;} } to be or not to be i=0 i=1 i=2 i=3 i=4 i=5 A[ ]

14 Sequence ADT: Array-Based Implementation (cont.) 14 class ArraySequence implements Sequence { } protected Object[ ] S; protected int size; public Object elematrank(int rank) throws { return (S[rank]).element(); } public Object replaceatrank(int rank, Object e) throws { Object temp = (S[rank]).element(); (S[rank]).setElement(e); return temp; } public ArrayPosition2 first() throws { ArrayPosition2 temp = S[0]; return temp; } public ArrayPosition2 last() throws { ArrayPosition temp = S[size]; return temp; }

15 Sequence ADT: Array-Based Implementation (cont.) 15 Example 1 [ insertion in case of clever array-sequence implementation ] to be or not to be Assume: i=0 i=1 i=2 i=3 i=4 i=5 A[ ] Execute: ArrayPosition2 p = myseq.last(); p Execute Insertion: new to be or maybe not to be i=0 i=1 i=2 i=3 i=4 i=5 i= The rank of Position that p is pointing to is automatically adjusted through S. " p

16 Sequence ADT: Array vs. Linked List Implementation 16 Run Times Sequence Method Array List size, isempty atrank, rankof, elementatrank first, last, before, after replaceelement, swapelements replaceatrank insertatrank, removeatrank insertafter, insertbefore remove Explain! Need rank-based access use array-based implementation. Need position-based updates use LL-based implementation. NOTE: Array-based and LL-based implementation have equally bad performance on the rank-based updated methods (insertatrank, removeatrank), though for different reasons. Explain!

17 Sequence ADT: Questions 17 Q.1 Explain why insertafter, insertbefore methods have running time in array-based sequence implementation. Q.2 Design algorithm for reversing a sequence that accesses the sequence only through a restricted set of methods, as indicated below. Each algorithm should only rearrange the elements of the sequence returning a new sequence is not allowed. However, using other sequences for auxiliary storage is allowed. (a) reverse a sequence using only methods: size, first, last, remove and insertfirst (b) reverse a sequence using only: size, first, remove, and insertfirst