Data Structures (Weiss) Chapter 5: Hash Tables without Linked Lists (quadratic probing)

//

//  main.cpp

//  Data Structure TRY1

//

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

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

//

// Data Structure C++, Weiss, P.197 Hash Tables Without Linked Lists

// quadratic probing

// here we do not define the function myhash( const HashedObj &x) 

#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;

}

template<typename HashedObj>

class HashTable

{

public:

    HashTable(int size=101): array( nextPrime(size))

    {

        makeEmpty();

    }

    

   bool contains( const HashedObj &x)const;

    

   void makeEmpty();

    

   bool insert( const HashedObj & x);

    // if x is already in the hash table, then return false and do not insert it; else if x is not in the table, then return true and insert it.

    

   bool remove( const HashedObj &x);

    // removed x successfully, return true; else return false;

    

   enum EntryType{ ACTIVE, EMPTY, DELETED};

    

private:

    

   struct HashEntry

    {

        HashedObj element;

        EntryType info;

        

        HashEntry(const HashedObj &e=HashedObj(), EntryType i=EMPTY)

        :element(e),info(i){}

    };

    

    vector<HashEntry> array;

   int currentSize;

    

   bool isActive( int currentPos)const

    {

       return array[currentPos].info==ACTIVE;

    }

    

   int findPos( const HashedObj &x)const

    {

       int offset=1;

       int currentPos=myhash(x);

        

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

        {

            currentPos+=offset;

            offset+=2;

           if( currentPos>=array.size())

                currentPos-=array.size();

        }

       return currentPos;

    }

    

   void rehash()

    {

        vector<HashEntry> oldArray=array;

        

        // Create new double-sized empty table

        array.resize(nextPrime(2*oldArray.size()));

        

        // Copy table over

        currentSize=0;

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

           if( oldArray[i].info==ACTIVE)

                insert(oldArray[i].element);

    }

    

   int myhash( const HashedObj &x)const; // not defined;

};

template<typename HashedObj>

void HashTable<HashedObj>::makeEmpty()

{

    currentSize=0;

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

        array[i].info=EMPTY;

}

template<typename HashedObj>

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

{

   return isActive(findPos(x));

}

template<typename HashedObj>

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

{

    // insert x as active

   int currentPos=findPos(x);

   if( isActive(currentPos))

        return false;

    

    array[currentPos]=HashEntry(x,ACTIVE);

    

    // Rehash

   if( ++currentSize>array.size()/2)

        rehash();

    

    return true;

}

template<typename HashedObj>

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

{

   int currentPos=findPos(x);

   if( !isActive(currentPos))

        return false;

    

    array[currentPos].info=DELETED;

    return true;

}

int main()

{

    

    

    

    

    

    

    

    return 0;

}