Associative ADTs

• Review Associative Containers
• Associative = access elements by value (not position)
• Set
• MultiSet
• Map
• MultiMap
• Table
• AssociativeArray
• Dictionary

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

Set and MultiSet

• Interface

//--------------------------
//   class Set<T,C>
//--------------------------

template < typename T , class C >
class Set
{
public:
  // Access support: SetIterator
  // Terminology support: value_type, Iterator
  // Proper type: constructors, destructors, assignment

  // element operations - modality determined by C
  Iterator  Insert  (const value_type& t);
  size_t    Remove  (const value_type& t);

  // locator operations
  Iterator  Includes     (const value_type& t) const;
  Iterator  Begin        () const;
  Iterator  End          () const;
  Iterator  rBegin       () const;
  Iterator  rEnd         () const;

  // size operations
  int       Empty   () const;
  size_t    Size    () const;

protected:
  C c;
} ; // class Set

//----------------------------------
//   class SetIterator<T,C>
//----------------------------------

template <typename T , class C>
class SetIterator
{
public:
  // Access support: Set
  // Terminology support: value_type
  // Proper type: constructors, destructors, assignment

  // operators
  int               operator == (const SetIterator<T,C>& I2) const;
  int               operator != (const SetIterator<T,C>& I2) const;
  value_type&       operator *  () const; // Return reference to current value
  SetIterator<T,C>& operator =  (const SetIterator <T,C> & I);
  SetIterator<T,C>& operator ++ ();    // prefix
  SetIterator<T,C>  operator ++ (int); // postfix
  SetIterator<T,C>& operator -- ();    // prefix
  SetIterator<T,C>  operator -- (int); // postfix

protected:
  typename C::Iterator i;
} ; // class SetIterator

• Dependencies on underlying C and implementation:
1. Uni/Multi
2. Sorted/Unsorted
3. Runtime and runspace efficiency of Insert(), Remove(), Includes(), Begin(), rBegin()
4. Runtime and runspace efficiency of Iterator operators ++() and --(),

Uni v Multi

• The Uni- and multi- versions of Set and Map differ in the semantics of Insert(t):
  1. Multi versions simple insert the new t according to whatever rules are used by the implementation
  2. Uni versions insert t if it is not already in the container, otherwise overwrite the existing item with t

Sorted v Unsorted (Hashed)

• Define a traversal of the container c of type C to be a loop

  for (C::Iterator I = c.Begin(); I != c.End(); ++I)
  {
    // any code in the body
  }
  

• The container C is sorted iff each traversal encounters elements in sorted order.
• Specifying that a container be sorted affects the implementation and consequently the runtime constraints on the operations.

Table, Map, AssociativeArray

• A Map [Table, Dictionary] is essentially a set of Key,Data pairs with equality and order operators defined to descend to the key.
• An associative array is a (uni)map with a special bracket operator:

  Data&             operator [] (const Key& k);
  

  Note that the argument is of type Key, not integer, and there is special semantics, wherein a call to the operator inserts the key into the table if it is not there.
• Table, Dictionary, and AssociativeArray are Unimodal only
• A MultiMap is essentially a MultiSet of Key,Data pairs with equality and order operators defined to descend to the key.

Associative Containers Summary

operation     Associative Container
---------     ---------------------------------------------------------------
              OUSet   OMSet    UUSet   UMSet   OUMap   OMMap    UUMap   UMMap
Insert(t)     log n   log n    AO(1)   AO(1)   
Insert(k,d)                                    log n   log n    AO(1)   AO(1)  
Remove(t)     log n   log n    AO(1)   AO(1)
Remove(k)                                      log n   log n    AO(1)   AO(1)  
Includes(t)   log n   log n    AO(1)   AO(1)
Includes(k)                                    log n   log n    AO(1)   AO(1)  
Includes(k,d)                                  log n   log n    AO(1)   AO(1)  
--------------
AO(1) = amortized constant runtime, 
        depends on hash function and internal sizing parameters 
-----------------------------------------------------------------------------
Iterator support:  Bidirectional

Special Purpose Associative Containers

AssociativeArray
PriorityQueue