ADTs and Data Structures

• Review: Abstract Data Types, Stacks and Queues
• Class = Interface + Operating Environment
• Interface = Collection of Algorithms with common Operating Environment
• Operating Environment = Implementation = Data Structure
• ADT = Interface + Operating Environment + Behavioral Constraints
• Behavioral Constraints: Functional, Runtime, and/or Runspace

Our Basic Tools

Abstract Container Types
Container	P|A	Iterator	Distinguishing Operations
Vector	P	RandomAccess	PushBack, PopBack, SetSize, Indexed BracketOperator
List	P	BiDirectional	PushFront, PopFront, PushBack, PopBack, Insert, Remove
Deque	P	RandomAccess	PushFront, PopFront, PushBack, PopBack, Indexed BracketOperator
Stack	P		Push, Pop, Top
Queue	P		Push, Pop, Front
PriorityQueue	A		Push, Pop, Front
OUSet	A	BiDirectional	Ordered UniSet: Insert, Remove, Includes
OMSet	A	BiDirectional	Ordered MultiSet: Insert, Remove, Includes
UUSet	A	BiDirectional	Unordered UniSet: Insert, Remove, Includes
UMSet	A	BiDirectional	Unordered MultiSet: Insert, Remove, Includes
AssociativeArray	A	BiDirectional	Unordered Associative Bracket Operator

For each operation: behavior specification, runtime constraint, runspace constraint

For each container: reason(s) to select it over the other choices

Sequential Containers

• Common API

template < typename T >
class SContainer
{
public:
  // Proper type: default constructor, copy constructor, destructor, assignment operator

  // Terminology support:
  typedef T                          ValueType;
  typedef SContainerIterator<T>      Iterator;
  typedef ConstSContainerIterator<T> ConstIterator;

  // tightly couple with Iterator

  // information accessors
  bool       Empty       () const;
  size_t     Size        () const;
  T&         Front       ();
  T&         Back        (); 
  const T&   Front       () const;
  const T&   Back        () const;

  // mutators
  bool       PushBack    (const T&);
  bool       PopBack     ();
  void       Clear       ();

  // Iterator support
  // Note: Iterator and ConstIterator are at least a bidirectional Iterators
  Iterator         Begin       ();
  Iterator         End         ();
  Iterator         rBegin      ();
  Iterator         rEnd        ();
  ConstIterator    Begin       () const;
  ConstIterator    End         () const;
  ConstIterator    rBegin      () const;
  ConstIterator    rEnd        () const;

} ;

• Common Efficiency Requirements (may be made more restrictive for specific containers)
  1. Each of the operations Empty(), Front(), Back(), and PopBack() has runtime Θ(1) and runspace +Θ(1)
  2. PushBack(t) has amortized runtime Θ(1), with worst case O(n), and runspace +Θ(1)
  3. The operations Size(), Clear(), constructor, destructor, copy constructor, and assignment operator have runtime <= O(n)

Vector

• Interface and Implementation Plan

template < typename T >
class Vector
{
public:
  // all default SContainer operations, plus:
  bool     SetSize     (size_t);
  bool     SetSize     (size_t, const T&);
  bool     SetCapacity (size_t);
  size_t   Capacity    () const;

  T&       operator[] (size_t index);
  const T& operator[] (size_t index) const;
  // Iterator is random access iterator
  // Iterator may be unsafe under container operations

private:
  // variables
  size_t size_,      // elements in vector 
         capacity_;  // size of underlying array data_
  T*     data_;      // pointer to the primative array elements
} ;

• Vector Efficiency Requirements (in addition to SContainer)
  1. Size() and Capacity() have runtime and runspace +Θ(1)
  2. SetSize(n) and SetCapacity() have runtime <= O(n) and runspace <= +O(n)
  3. operator[] has runtime Θ(1) and runspace +Θ(1)

List

• Interface and Implementation Plan

template < typename T >
class List
{
public:
  // all default SContainer operations, plus:

  bool       PushFront   (const T&);
  bool       PopFront    ();
  bool       Insert      (Iterator& , const T&);
  bool       Remove      (Iterator&);

  // Iterator is safe under insert operations
  // Iterator is unsafe under remove operations

private:
  // type
  class Link
  {
    friend class List;
    Link(const T& t) : value_(t), prevLink_(0), nextLink_(0){}
    T      value_;
    Link * prevLink_;
    Link * nextLink_;
  };

  // variables
  Link * firstLink_;
  Link * lastLink_;
} ;

• List Efficiency Requirements (in addition to SContainer)
  1. PushBack(t), PushFront(t), Insert(i,t), and Remove(i) have runtime Θ(1) and runspace +Θ(1)
  2. Size() has runtime Θ(n) and runspace +Θ(1)

Deque

• Interface and Implementation Plan

template < typename T >
class Deque
{
public:
  // all default SContainer operations, plus:

  bool       PushFront   (const T&);
  bool       PopFront    ();
  T&         operator[] (size_t index);
  const T&   operator[] (size_t index) const;

  // Iterator is random access iterator
  // Iterator is safe under container operations

private:
  // variables
  size_t beg_,   // first element
         end_,   // 1 past last element
         size_;  // size allocated to data_
  T *    data_;  // storage array
} ;

• Deque Efficiency Requirements (in addition to SContainer)
  1. PushBack(t) and PushFront(t) have amortized constant runtime, with worst case O(n)
  2. Size() has runtime Θ(1) and runspace +Θ(1)
  3. operator[] has runtime Θ(1) and runspace +Θ(1)

Bidirectional Iterators

• Common API

template <typename T>
class BidirectionalIterator
{
public:
  // terminology support
  typedef T                      ValueType;
  typedef BidirectionalIterator  Iterator;

  // tightly couple with container

  // Proper type: default constructor, copy constructor, destructor, assignment

  // Bidirectional Iterator protocol
  bool       operator == (const Iterator& i2) const;
  bool       operator != (const Iterator& i2) const;
  T&         operator *  (); // Return reference to current Tval omit for ConstIterator
  const T&   operator *  () const; // const version
  Iterator&  operator =  (const Iterator  & i);
  Iterator&  operator ++ ();    // prefix
  Iterator   operator ++ (int); // postfix
  Iterator&  operator -- ();    // prefix
  Iterator   operator -- (int); // postfix
} ;

• Efficiency Constraints
1. All operations have constant runtime and runspace

Random Access Iterators

• Common API

template <typename T>
class RandomAccessIterator
{
public:
  // Bidirectional Iterator, plus bracket operator and "pointer" arithmetic:

  T&        operator [] (size_t index); // omit for ConstIterator
  const T&  operator [] (size_t index) const; // const version

  long      operator -  (const Iterator & i2) const;

  template <typename N>
  Iterator  operator +  (N n) const;

  template <typename N>
  Iterator& operator += (N n);

  template <typename N>
  Iterator& operator -= (N n);
} ;

• Efficiency Constraints
1. All operations have constant runtime and runspace

VectorIterator

template <typename T>
class VectorIterator
{
  friend class Vector<T>

public:
  // Random Access Iterator

private:
  T* Tptr_;
} ;

ListIterator

template <typename T>
class ListIterator
{
  friend class List<T>

public:
  // Bidirectional Iterator

private:
  typename List::Link * currLink_;
} ;

DequeIterator

template <typename T>
class DequeIterator
{
  friend class Deque<T>

public:
  // Random Access Iterator

private:
  typename Deque<T> * myDeque_;
  size_t              myIndex_;
} ;

Sequential Containers Summary

                       Vector        List         Deque

PushFront(t)                         O(1)         AO(1)
PopFront()                           O(1)         O(1)
PushBack(t)            AO(1)         O(1)         AO(1)
PopBack()              O(1)          O(1)         O(1)
Insert(i,t)                          O(1)
Remove(i)                            O(1)
Resize(n)              O(size)
Iterator Support       RA            BD           RA
Search Algorithm       Binary(*)     Sequential   Binary(*)
---------
(*) if range is sorted, otherwise use sequential search 

Stack < T , Vector < T > >
Stack < T , List   < T > >
Stack < T , Deque  < T > > // default
Queue < T , List   < T > >
Queue < T , Deque  < T > > // default