1

2
0 100 Suppose you delete 121 from the table.

1 121

2 289
3 361
4 144
5 225
6 196
7 256
8 324
9 169
3
0 100 Suppose you delete 121 from the table.

1 Now you want to search for 361, you hash to

position 1, it is empty so you decide 361 is not
2 289
in the table. NOT GOOD.
3 361
4 144
5 225
6 196
7 256
8 324
9 169
4
0 100 Suppose you delete 121 from the
table by marking the cell as deleted
1 121

2 289
3 361
4 144
5 225
6 196
7 256
8 324
9 169
5
0 100 Suppose you delete 121 from the
table by marking the cell as deleted
1 121

2 289 Now you want to search for 361, you hash to

3 361 position 1, it is deleted so you keep on going
based on your collision detection strategy
4 144 and find 361 two probes later.
5 225
6 196
7 256
8 324
9 169
6
0 100 Suppose you want to insert 521
1 121
to the hash table
2 289
3 361
4 144
5 225
6 196
7 256
8 324
9 169
7
0 100 Suppose you want to insert 521
1 521
to the hash table
2 289
3 361
4 144
5 225
6 196
7 256
8 324
9 169
8
9
10
0 Initially the hash table is empty
1

9
11
0 100 Insert 100
1

9
12
0 100 Insert 121
1 121

9
13
0 100 Insert 144
1 121

4 144
5

9
14
0 100 Insert 169
1 121

4 144
5

9 169
15
0 100 Insert 196
1 121

4 144
5

6 196
7

9 169
16
0 100 Insert 225
1 121

4 144
5 225
6 196
7

9 169
17
0 100 Insert 256 COLLISION because location
1 121 6 is full. Try location 6+1=7
2

4 144
5 225
6 196
7 256
8

9 169
18
0 100 Insert 289 COLLISION because location
1 121
9 is full.
2

4 144
5 225
6 196
7 256
8

9 169
19
0 100 Insert 289 COLLISION because location
1 121
9 is full.
2

3 Try location (9+1)mod 10= 0 FULL

4 144
5 225
6 196
7 256
8

9 169
20
0 100 Insert 289 COLLISION because location
1 121
9 is full.
2

3 289 Try location (9+1)mod 10= 0 FULL

4 144
5 225
Try location (9+4)mod 10= 3 AVAILABLE
6 196
7 256
8

9 169
21
0 100 Insert 324 COLLISION because location
1 121
4 is full.
2

3 289 Try location (4+1)mod 10= 5 FULL

4 144
5 225
6 196
7 256
8

9 169
22
0 100 Insert 324 COLLISION because location
1 121
4 is full.
2

3 289 Try location (4+1)mod 10= 5 FULL

4 144
5 225
Try location (4+4)mod 10= 8 AVAILABLE
6 196
7 256
8 324
9 169
23
0 100 Insert 361 COLLISION because location
1 121
1 is full.
2 361
3 289 Try location (1+1)mod 10= 2 AVAILABLE
4 144
5 225
6 196
7 256
8 324
9 169
24
25
26
27
 2 j
( hash ( x )  i ) mod M  ( hash ( x )  ) mod M
2

i mod M  j mod M
2
2
(Why ?) 

28
 2 j
( hash ( x )  i ) mod M  ( hash ( x )  ) mod M
2

i  j  0 mod M
2 2


( i  j )( i  j )  0 mod M
29
( i  j )( i  j )  0 mod M 

( i  j )( i  j )  kM 

30
( i  j )( i  j )  0 mod M 

( i  j )( i  j )  kM 

 M
1  i,j   
2 

31
32
template <class HashedObj>
class HashTable
{
public:
explicit HashTable( const HashedObj & notFound, int size = 101 );
HashTable( const HashTable & rhs )
: ITEM_NOT_FOUND( rhs.ITEM_NOT_FOUND ),
array( rhs.array ), currentSize( rhs.currentSize ) { }

const HashedObj & find( const HashedObj & x ) const;

void makeEmpty( );
void insert( const HashedObj & x );
void remove( const HashedObj & x );

const HashTable & operator=( const HashTable & rhs );

enum EntryType { ACTIVE, EMPTY, DELETED }; 33

template <class HashedObj>
class HashTable
{
public:
explicit HashTable( const HashedObj & notFound, int size = 101 );
HashTable( const HashTable & rhs )
: ITEM_NOT_FOUND( rhs.ITEM_NOT_FOUND ),
array( rhs.array ), currentSize( rhs.currentSize ) { }

const HashedObj & find( const HashedObj & x ) const;

void makeEmpty( );
void insert( const HashedObj & x );
void remove( const HashedObj & x );

const HashTable & operator=( const HashTable & rhs );

enum EntryType { ACTIVE, EMPTY, DELETED }; 34

template <class HashedObj>
class HashTable
{
public:
explicit HashTable( const HashedObj & notFound, int size = 101 );
HashTable( const HashTable & rhs )
: ITEM_NOT_FOUND( rhs.ITEM_NOT_FOUND ),
array( rhs.array ), currentSize( rhs.currentSize ) { }

const HashedObj & find( const HashedObj & x ) const;

void makeEmpty( );
void insert( const HashedObj & x );
void remove( const HashedObj & x );

const HashTable & operator=( const HashTable & rhs );

enum EntryType { ACTIVE, EMPTY, DELETED }; 35

private:
struct HashEntry
{
HashedObj element;
EntryType info;

HashEntry( const HashedObj & e = HashedObj( ),

EntryType i = EMPTY )
: element( e ), info( i ) { }
};

vector<HashEntry> array;
int currentSize;
const HashedObj ITEM_NOT_FOUND;

bool isActive( int currentPos ) const;

int findPos( const HashedObj & x ) const;
void rehash( );
}; 36
/**
* Construct the hash table.
*/
template <class HashedObj>
HashTable<HashedObj>::HashTable( const HashedObj & notFound,
int size )
: ITEM_NOT_FOUND( notFound ), array( nextPrime( size ) )
{
makeEmpty( );
}

37
/**
* Method that performs quadratic probing resolution.
* Return the position where the search for x terminates.
*/
template <class HashedObj>
int HashTable<HashedObj>::findPos( const HashedObj & x ) const
{
int collisionNum = 0;
int currentPos = hash( x, array.size( ) );

while ( array[ currentPos ].info != EMPTY &&

array[ currentPos ].element != x )
{
currentPos += pow(++collisionNum, 2) ; //add the difference
if ( currentPos >= array.size( ) ) // perform the mod
currentPos –= array.size( ); // if necessary
}
return currentPos;
} 38
/**
* Return true if currentPos exists and is active.
*/
template <class HashedObj>
bool HashTable<HashedObj>::isActive( int currentPos ) const
{
return array[ currentPos ].info == ACTIVE;
}

39
/**
* Remove item x from the hash table.
* x has to be in the table
*/
template <class HashedObj>
void HashTable<HashedObj>::remove( const HashedObj & x )
{
int currentPos = findPos( x );
if ( isActive( currentPos ) )
array[ currentPos ].info = DELETED;
}

40
/**
* Find item x in the hash table.
* Return the matching item, or ITEM_NOT_FOUND, if not found.
*/
template <class HashedObj>
const HashedObj & HashTable<HashedObj>::find( const HashedObj & x )
const
{
int currentPos = findPos( x );
if (isActive( currentPos ))
return array[ currentPos ].element;

return ITEM_NOT_FOUND;
}

41
/**
* Insert item x into the hash table. If the item is
* already present, then do nothing.
*/
template <class HashedObj>
void HashTable<HashedObj>::insert( const HashedObj & x )
{
// Insert x as active
int currentPos = findPos( x );
if ( isActive( currentPos ) )
return;
array[ currentPos ] = HashEntry( x, ACTIVE );

// enlarge the hash table if necessary

if ( ++currentSize >= array.size( ) / 2 )
rehash( );
} 42
43
/**
* Expand the hash table.
*/
template <class HashedObj>
void HashTable<HashedObj>::rehash( )
{
vector<HashEntry> oldArray = array;

// Create new double-sized, empty table

array.resize( nextPrime( 2 * oldArray.size( ) ) );
for ( int j = 0; j < array.size( ); j++ )
array[ j ].info = EMPTY;

// Copy table over

currentSize = 0;
for ( int i = 0; i < oldArray.size( ); i++ )
if ( oldArray[ i ].info == ACTIVE )
insert( oldArray[ i ].element );
} 44
45
46
47
48