Data Structures (Weiss) Chapter 5: Separate Chain

//

// main.cpp

// Data Structure TRY1

//

// Created by zr9558 on 6/7/13.

// Copyright (c) 2013 zr9558. All rights reserved.

//

// Data Structure C++, Weiss, P.189 Separate Chaining

// we can not use the class HashTable directly, since there is a hash function in the class which we do not define it. Therefore, in P.190, the author gives an example about Employee.

#include<iostream>

using namespace
std;

#include<vector>

#include<list>

#include<algorithm>

bool isPrime(
int n)
{

for( int i=2; i*i<=n; ++i)

if( n%i==0)
return false;



return
true;
}

// nextPrime is used in rehash function.
int nextPrime(int n)
{

while( !isPrime(n)) ++n;



return n;
}

// 37 is a prime. The hash function is a hash function for string.
int hash(
const string &key)
{

int hashVal=0;

for( int i=0; i!=key.size(); ++i)
hashVal+=37*hashVal+key[i];



return hashVal;
}

// The hash function is a hash function for integers.
int hash(
int key)
{

return key;
}

template<typename HashedObj>
class HashTable
{

public:
HashTable(
int size=101);



bool contains( const HashedObj &x)
const;



void makeEmpty();
// clear all lists

bool insert( const HashedObj &x);

// x is already in HashTable, return false; else return true;

bool remove( const HashedObj &x);

// x is in HashTable and remove it, return true; else return false;



private:

vector<list<HashedObj> > theLists;

int currentSize;



void rehash()
{

vector<list<HashedObj> > oldLists=theLists;

// Create new double-sized, empty table;

theLists.resize(nextPrime(2*theLists.size()));

for( int j=0; j<theLists.size(); ++j)

theLists[j].clear();



//Copy table over

currentSize=0;

for( int i=0; i<oldLists.size(); ++i)
{

list<HashedObj>::iterator itr=oldLists[i].begin();

while( itr!=oldLists[i].end())
insert( *itr++);
}
}



int myhash( const HashedObj &x)
const
{

int hashVal=hash(x);
// the hash function changes HashedObj x to an integer


hashVal%=theLists.size();

if( hashVal<0)
hashVal+=theLists.size();



return hashVal;
}
};

template<typename HashedObj>
void
HashTable<HashedObj>::makeEmpty()
{

for( int i=0; i<theLists.size(); ++i)

theLists[i].clear();
}

template<typename HashedObj>
bool
HashTable<HashedObj>::contains(
const HashedObj &x) const
{

const list<HashedObj> & whichList=
theLists[myhash(x)];

return find(whichList.begin(), whichList.end(),x)!=whichList.end();
}

template<typename HashedObj>
bool
HashTable<HashedObj>::remove(
const HashedObj &x)
{

list<HashedObj> & whichList=theLists[myhash(x)];



if( find(whichList.begin(), whichList.end(),x)==whichList.end())
return false;


whichList.erase( find(whichList.begin(), whichList.end(),x)==whichList.end());



--currentSize;

return
true;
}

template<typename HashedObj>
bool
HashTable<HashedObj>::insert(const HashedObj &x)
{

list<HashedObj> & whichList=theLists[myhash(x)];

if( find(whichList.begin(), whichList.end(),x)==whichList.end())
return false;


whichList.push_back(x);



if( ++currentSize>theLists.size())

rehash();

return
true;
}

int main()
{















return
0;
}