Positional Sequences Section 4.2

Transcription

1 Positional Sequences Section 4.2 PS-1

2 Problem with Ranked Sequences Problem with ranked sequences» rank of a particular element may change as other elements are inserted and deleted For example if you have a ranked sequence of peoples names and telephone numbers» Alice is currently at rank 5 > Insert Ali and the rank of Alice may change to 6 > Delete Leila and the rank of Alice may change to 4 Difficult to keep track of the rank of specific elements PS-2

3 Positions Instead of remembering a rank we remember a position Retrieval and insert operations are relative to a position Before aposition After aposition Insert before aposition Insert after aposition aposition PS-3

4 Other terminology Before head / first null head / first last After last null Insert after null insert as first Insert before null insert as last PS-4

5 What happens on insertion & removal? Position is not affected, even though rank changes aposition insert before aposition remove pos_ O pos_2 aposition PS-5

6 What is a Position? An ADT represented by an abstract class public abstract class Position { abstract Object element(); // Require: True // Ensure: Result = data at the position Sequence container() { return container; }... One or more methods not implemented, Can have objects // Require: True // Ensure: Result = container holding element PS-6

7 Position creation Need a reference to the container to which the position refers... Sequence container; Position ( Sequence container) { this.container = container; } Element "pointer" is implementation dependent > Cannot define the pointer yet. PS-7

8 The Real Picture of a Position The sequence is a container holding the sequence elements Point to sequence. It is a container Point to element aposition PS-8

9 An Analogy contains identification apt #(element) address (container) Position (you) points to container and points to an element PS-9

10 Why the Container Requirement? Consider case without the container requirement (1) PosSeq s1 = new PosSeq s1 λ (2) PosSeq s2 = new PosSeq s1 λ s2 λ PS-10

11 Why the Container Requirement? 2 (3) Position p1 = s1.insertfirst (A) p1 s1 s2 λ A (4) Position p2 = s2.insertafter( p1, B ) p1 s1 p2 s2 λ A succ pred B??? surprise!!! s1 is modified s2.size = 1 s1.size = 1 PS-11

12 Container Sequence Positional Seq A positional sequence can be used anywhere a sequence can be used * Container * Sequence * PositionalSequence PS_array PS_DLL PS-12

13 Interface 1 From container example meaning that could be given to operations with ambiguous meanings boolean contains ( Object obj ); boolean isempty (); boolean isfull (); int size (); void add ( Object obj ); // insertlast (obj ) void removeall (); Object remove (); // removelast () boolean equals ( Container container ); PS-13

14 Interface 2 From sequence keep with original meaning void puthead (Object obj ); // Insert at head of sequence // insertfirst(obj) Object takehead (); // Remove the head of the sequence // removelast() PS-14

15 Interface 3 New to positional sequence Position first (); > Require: True Ensure: size > 0 Result = element at head size = 0 Result = null Position last (); > Require: True Ensure: size > 0 Result = element at last size = 0 Result = null PS-15

16 Interface 4 Contract differs from textbook > Caller is to ensure correct container is used See slide "Why the container requirement" > Null is returned instead of an error for "before first" and "after last" Position before ( Position pos ); > Require: this.container = pos.container Ensure: Result = predecessor ( pos ) Position after ( Position pos ); > Require: this.container = pos.container Ensure: Result = successor ( pos ) PS-16

17 Interface 5 Position insertfirst ( Object obj ); > Require: this.container.size < this.container.capacity Ensure: Result = first sequence = < obj > ^ old sequence Position insertlast ( Object obj ); > Require: this.container.size < this.container.capacity Ensure: Result = last sequence = old sequence ^ < obj > PS-17

18 Interface 6 Position insertbefore ( Position pos, Object obj ); Require: this.container = pos.container this.container.size < this.container.capacity Ensure: pos null Result = predecessor ( pos ) sequence = old sequence [ first.. old pred ( pos ) ] ^ < obj > ^ old sequence [ pos.. last ] pos = null insertlast PS-18

19 Interface 7 Position insertafter ( Position pos, Object obj ); >Require: this.container = pos.container this.container.size < this.container.capacity Ensure: pos null Result = successor ( pos ) sequence = old sequence [ first.. pos ] ^ < obj > ^ old sequence [ old succ ( pos ).. last ] pos = null insertfirst PS-19

20 Interface 7 void remove ( Position pos ); > Require: this.container = pos.container Ensure: sequence = old sequence [ first.. pred ( pos ) ] ^ old sequence [ succ ( pos ).. last ] void replace ( Position pos, Object obj ); > Require: this.container = pos.container Ensure: sequence = old sequence [ first.. pred ( pos ) ] ^ < obj > ^ old sequence [ succ ( pos ).. last ] PS-20

21 DLL Implementation The most natural implementation is to use a doubly linked list» Before and After are aliases for the predecessor and successor pointers in doubly linked list nodes Unlike ranked sequence there is no need to search for the position already have it.» If position is known, then insert and remove are O(1) with positional sequences compared to O(n) for ranked sequences PS-21

22 DLL insertafter ( O, position ) size trailer header 3 4 position trailer header before insert after insert O 3 PS-22

23 DLL remove ( position ) position size trailer header 3 2 trailer header before remove after remove PS-23

24 The Class Structure * Container * Position * Sequence DLL_Position * PosSeq DLL_Node PS_DLL DLList Uses need two arrow heads for slide as double line is not easily seen PS-24

25 DLL Position public class DLL_Position implements Position { // Reference to doubly linked list node in a sequence public DLL_Node element; Object element() { return element.getdata(); }... PS-25

26 DLL Position Constructor... public DLL_Position ( DLL_PositionalSequence container, DLL_Node element ) { } // Position is created first and it needs a parameter super ( container ); this.element = element; } // end of DLL_Position PS-26

27 DLL Positional Sequence Constructor public class DLL_PositionalSequence implements PositionalSequence { // Use doubly linked list that can access list metadata DLList theseq public DLL_PositionalSequence () { } theseq = new DLList (); PS-27

28 DLL Positional Sequence insertfirst // Using Adapter pattern public Position insertfirst ( Object data ) { theseq.puthead ( data ) return new DLL_Position ( this, theseq.head () ); } PS-28

29 DLL Positional Sequence insertafter public Position insertafter ( Position pos, Object data ) { } if ( pos == null ) { return insertfirst ( data ); } //** DLL_Node element = ( ( DLL_Position ) pos ).element theseq.insertafter ( element, data ); return new DLL_Position ( this, element.successor() ) ** Do not need if DLL insertafter accepts null as meaning insert at head PS-29

30 DLL Positional Sequence before 1 // If header and trailer nodes are used in the DLL have to // check for the first position since the node will point to // the dummy header instead of null. public Position before ( Position pos ) { } if ( pos == null ) return last(); if ( pos == first() ) return null; return new DLL_Position ( this, ( ( DLL_Position ) pos ).element.predecessor() ) // In pseudocode the return statement would be simpler // return new DLL_Position ( this, pos.predecessor ) PS-30

31 DLL Positional Sequence before 2 // If header and trailer nodes are not used in the DLL public Position before ( Position pos ) { if ( pos == null ) return last(); } return new DLL_Position ( this, ( ( DLL_Position ) pos ).element. predecessor() ) PS-31

32 Array implementation Problem Pointer to the element is an array index. pos_1 pos_2 3 pos_3 size Must change "pointers" in pos_2 & pos_3 due to insert & remove operations pos_1 O 4 pos_3 How to find the other positions for update? pos_2 PS-32

33 Array implementation Store the data in the position. Array elements point to the position data container index = 3 aposition 3 size PS-33

34 Insert / Remove Update index value in each position as the array elements are shifted due insert & remove operations Positions showing index value p1 p2 p O p1 p2 p3 PS-34

35 Array Position public class Array_Position extends Position { Object data; int index; Object element() { return data; }... PS-35

36 Array Position Constructor... Array_Position ( Array_PositionalSequence container, Object data, int index ) { } // Position is created first and it needs a parameter super ( container ); this. data = data; this.index = index; } // end of Array_Position PS-36

37 Array Position Sequence Constructor public class Array_PositionalSequence extends PositionalSequence { private Array_Position [ ] theseq; private int Capacity; private int size; public Array_PositionalSequence ( int Capacity ) { theseq = new Array_Position [ Capacity ]; this.capacity = Capacity; size = 0; } PS-37

38 Array Pos Seq insertfirst public Position insertfirst ( Object obj ) { Array_Position newposition = new Array_Position ( this, obj, 0); /* Loop invariant: sequence[i+1.. old size] = old sequence[i.. old size - 1] */ for (int i = size ; i > 0 ; i-- ) { theseq [ i ] = theseq [ i 1 ]; theseq [ i ].index = i; } } theseq [ 0 ] = newposition; size++; return newposition; PS-38

39 Array Pos Seq insertbefore public Position insertbefore ( Position pos, Object obj ) { if ( pos == null ) // Special case for insert as last { return insertlast ( obj); } } else { return insertafter( before ( pos ), obj ); } PS-39

40 Array Pos Seq before public Position before ( Position pos ) { if ( pos == null ) return last(); if ( pos == first () ) // Special case when first { return null; } else { return theseq [ pos.index 1]; } PS-40

41 Array Pos Seq insertafter public Position insertafter ( Position pos, Object obj ) { if ( pos == null ) // Special case if no position is given { return insertfirst ( obj ); } Array_Position newposition = new Array_Position ( this, obj, pos.index + 1); // see next slide } PS-41

42 Array Pos Seq insertafter 1 /* Loop invariant: sequence[i+1.. old size+1] = old sequence[i.. old size] */ for ( int i = size ; i > pos.index ; i-- ) { theseq [ i + 1 ] = theseq [ i ]; theseq [ i + 1 ].index = i + 1; } } theseq [ pos.index + 1 ] = newposition; size++; return newposition; PS-42