Associative ADTs

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

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

• Set < List > // sorted
• Set < BinaryTree > // sorted
• Set < Vector of Lists > // hashed
• Map < Set < Pair > >
• Map = Dictionary = Table
• AssociativeArray = Table + Bracket Operator
• MultiSet < List > // sorted
• MultiSet < BinaryTree > // sorted
• MultiSet < Vector of Lists > // hashed
• MultiMap < MultiSet < Pair > >