Sequences

The Sequence Abstract Data Type

Implementing a Sequence

Sequence ADT Positionrank Doubly linked list DNodeatRank(r) rankOf(p) Implementation of a sequence with a doubly linked list:

Implementing a Sequence with a Doubly Linked List

Class NodeSequence

The methods to be implemented in class NodeSequence: Methods defined in Vector: void insertAtRank(int rank, Object element) Object removeAtRank(int rank) Object replaceAtRank(int rank, Object element) Object elemAtRank (int r) Auxiliary method: void checkRank(int rank, int range) Bridging methods: Position atRank(int rank) rankOf(Position p)

public Position atRank( int rank ) { DNode node; int n = size(); checkRank( rank, n ); if( rank <= n / 2 ) { node = header.getNext(); for( int i = 0; i < rank; i++ ) { node = node.getNext(); } } else { node = trailer.getPrev(); for( int i = 1; i < n - rank; i++ ) { node = node.getPrev(); } } return node; } 0 1 r 2 n-2n-1 Number of hopping = r i=0,1,...,r-1 Number of hopping = n-r-1 i=1,2,...,n-r-1 n-3

/** Gets an element at the given rank.*/ public Object elemAtRank(int r) { return atRank(r).element(); } /** Returns the rank of a given position.*/ public int rankOf(Position p) { DNode node; node = header.getNext(); for (int i=1; i < size(); i++) { if (p == node) return i; else node = node.getNext();} }

/** 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 = 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(); for (int i=1; i < size()-rank; i++) node = node.getPrev();} return node; }

/** Gets an element at the given rank.*/ public Object elemAtRank(int r) { return atRank(r).element(); } /** Returns the rank of a given position.*/ public int rankOf(Position p) { DNode node; node = header.getNext(); for (int i=1; i < size(); i++) { if (p == node) return i; else node = node.getNext();} }

/** 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)); } public Object replaceAtRank(int rank, object element) throws BoundadryViolationException { checkRank(rank); return replaceElement(atRank(rank), element); }

Implementing a Sequence with an Array

Comparing Sequence Implementations

Interface Hierarchy for Vectors, Lists, and Sequences Vector (interface)List (interface) Sequence (interface)ArrayVector (class)NodeList (class) ArraySequence (class)NodeSequence (class) impl. extends impl. extends Supplement with the methods in Vector interface Supplement with the methods in List interface impl.

Data Structure Exercises 9.1

Iterators

The Iterator Abstract Data Type

Iterators in Java (in package java.util)

An implementation of the Iterator is always related to container, i.e., a vector, a list, or a sequence. The following is an exemplary implementation of the List Iterator. 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 {try { cur = list.after(cur) } catch (InvalidPositionException e) { } } // move cursor to the next position return toReturn; }

class NoSuchElementException extends Exception { public NoSuchElementException() {super();} public NoSuchElementException(String s) { super(s); } }

In a similar way, we can establish an ElementIterator as follows. public class ElementIterator implements Iterator { protected List list; // the underlying list protected Position cur; // the current (next) position protected Object elementCur; // the current (next) element public ElementIterator() { } // default constructor public ElementIterator(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"); elementCur = cur.element(); if (cur == list.last()) cur = null; // no positions left else {try { cur = list.after(cur) } catch (InvalidPositionException e) { } } // move cursor to the next position return elementCur; }

Data Structure Exercises 10.1

Case Study: Bubble-Sort on a Sequence

The Bubble-Sort Algorithm

2, 3, 5, 6, 7, 9 i for a certain i r

Bubble Sort Using Ranks

If the sequence is array-based, the running time is proportional to the square of n, the size of the sequence: running time O(n 2 ). On the other hand, if the sequence is position-based, the running time is proportional to n 3. running time O(n 3 ). In this case, the atRank operation needs to perform link hopping.

Bubble Sort Using Positions

The running time is proportional to the square of n, the size of the sequence, regardless of how the sequence is implemented: running time O(n 2 ).

Data Structure Exercises 9.2