Strategy pattern - design hash table
You're misusing the term strategy pattern.
Instead of doing this kind of thing:


template &lt;class K, class V&gt;
void Map&lt;K,V&gt;::SetDataStructureStrategy(int ds_type)
{
  if(ds_ != NULL)
  {
    delete ds_;
  }

  if(ds_type == DSType::DYNAMIC_MAP)
  {
    ds_ = new DynamicMap&lt;K,V&gt;;
  }
  else if(ds_type == DSType::ARRAY_MAP)
  {
    ds_ = new ArrayMap&lt;K,V&gt;;
  }
}



The strategy pattern would look something more like this:

template &lt;class K, class V&gt;
void Map&lt;K,V&gt;::SetDataStructureStrategy(DataStructureStrategy * dsStrategy)
{
  this-&gt;dsStrategy = dsStrategy;
}


That is, you would have a DataStructureStrategy abstract parent class,
with concrete implementations in subclasses,
for example DynamicMapStrategy and ArrayMapStrategy.

And then, the code to initialize the data structure would look like this:

ds_ = dsStrategy-&gt;newDataStructure();


where newDataStructure would be implemented in the specialized subclasses like this:

// implementation of DynamicMapStrategy::newDataStructure
return new DynamicMap&lt;K,V&gt;;

// implementation of ArrayMapStrategy::newDataStructure
return new ArrayMap&lt;K,V&gt;;


In other words:


Your hashmap class shouldn't have to know how a strategy is implemented. At no point should the code have conditional statements on DSType. In fact there's no need for DSType. 
The same goes for all the other kind of strategies that you implied: hash strategy, collision strategy. Define a common interface for each strategy that the hashmap wants to work with. Move the implementations of strategies outside of the hashmap, into subclasses of the common interfaces.
These strategies should not change during the lifetime of a hashmap. It wouldn't be efficient to switch the strategy of an existing hashmap. So it would be better to make these strategies required at construction time, and remove the setters.