Question

How do I do this? -> string print() const; Function to output the data, return the output in the form of string, with all elements in the hash table included and each seperated by a space

this is my code:

template <class elemType>
string hashT<elemType>::print() const
{
for (int i = 0; i < HTSize; i++){
       if (indexStatusList[i] == 1){
       cout <<HTable[i]<< " " << endl;
       }  
}   
}

**********Rest of the code if needed with what the functions do **************************************

• hashT(int size = 101); The constructor. Create the arrays HTTable and indexStatusList, then size of both of them would be given by the parameter size; initialize each element of the array indexStatusList to 0; length = 0 (hash table is empty); HTSize = size; and the default array size is 101.

• void insert(const elemType& rec); Function to insert an item in the hash table. The item to be inserted is specified by the parameter rec. Postcondition: If an empty position is found in the hash table, rec is inserted and the length is incremented by one; otherwise, an appropriate error message is displayed.

• int search(const elemType& rec, bool& found) const; Function to determine whether the item specified by the parameter rec is in the hash table. The function returns the number of access before the method returns. Postcondition: If rec is found, found is set to true; otherwise, found is set to false.

• void remove(const elemType& rec); Function to remove an item from the hash table. Postcondition: If rec is found in the table it is removed; otherwise, an appropriate error message is displayed.

• string print() const; Function to output the data, return the output in the form of string, with all elements in the hash table included and each seperated by a space.

• int hashFunction(elemType key); Hash function that returns the hashed value of the input.

• ~hashT(); The destructor.

The following private methods are already offered to you in the template:

-- bool isItemAtEqual(int hashIndex, const elemType& rec) const; Function to determine whether the item specified by the parameter rec is the same as the item in the hash table at position hashIndex. Postcondition: Returns true if HTable[hashIndex] == rec; otherwise, returns false.

-- int hashFunction(const elemType& rec) const; This function returns the hash index for a given element rec.

-- int nextProbingPlace(int placenow, int probingtime) const; This function helps you find where the next place is to look into to find out where rec is.

rest of the code if needed.

#include<string>
#include<iostream>
#include <sstream>
using namespace std;
#ifndef HASHT_H
#define HASHT_H

template <class elemType>
class hashT
{
public:
   hashT(int size = 101);

   void insert(const elemType& rec);

   int search(const elemType& rec, bool& found) const;

   void remove(const elemType& rec);

   string print() const;

   ~hashT();
private:

   int nextProbingPlace(int place_now, int probing_time) const;

   int hashFunction(const elemType& key) const;

   bool isItemAtEqual(int hashIndex, const elemType& rec) const;

  

   private:
   elemType *HTable; //pointer to the hash table
   int *indexStatusList; //pointer to the array indicating the
   //status of a position in the hash table
   int length; //number of items in the hash table
   int HTSize; //maximum size of the hash table
};
#endif

template <class elemType>
int hashT<elemType>::hashFunction(const elemType& key) const
{

   ostringstream oss;
   oss<<key;
   string key_str = oss.str();
   int sum = 0;
   for (int j = 0; j < key_str.size(); j++)
       sum = sum + static_cast<int>(key_str.at(j));
   return (sum % HTSize);
}

template <class elemType>
int hashT<elemType>::nextProbingPlace(int place_now, int probing_time) const
{
   int result = (place_now+1)%HTSize;
   return result;
}

template <class elemType>
bool hashT<elemType>::isItemAtEqual(int hashIndex, const elemType& rec) const
{
   //cout<<"Inside"<<indexStatusList[hashIndex]<<endl;
   if(hashIndex<0 || hashIndex>=HTSize || indexStatusList[hashIndex]==0 )
       return false;

   return HTable[hashIndex] == rec;
}

template <class elemType>
hashT<elemType>::hashT(int size)
{
size = 101;
HTable = new elemType[size];
indexStatusList = new int[size];
HTSize = size;
length = 0;
for (int i = 0; i < size; i++) {
indexStatusList[i] = 0;
}
}

template <class elemType>
void hashT<elemType>::insert(const elemType& rec)
{
int inc = 1;
int pCount = 0;
int hashIndex = hashFunction ( rec );
while(indexStatusList[hashIndex] == 1 && HTable[hashIndex] != rec && pCount < HTSize / 2)
   {
       pCount++;
       hashIndex = (hashIndex + inc ) % HTSize;
       inc = inc + 2;
   }

   if(indexStatusList[hashIndex] != 1)
   {
       HTable[hashIndex] = rec;
       indexStatusList[hashIndex] = 1;
       length++;
   }
else if (HTable[hashIndex] == rec)
cout << "Error: No duplicates are allowed."<<endl; // cerr is used for error outputs
else
cout << "Error: The table is full."
<<"Unable to resole collision" << endl;
}

template <class elemType>
int hashT<elemType>::search(const elemType& rec, bool& found) const
{
int hashIndex = hashFunction ( rec ) ;
int pCount = 0;
int inc = 1;
  
   while(indexStatusList[hashIndex]!= 0 && HTable[hashIndex] != rec && pCount < HTSize / 2)
   {
       pCount++;
       hashIndex = (hashIndex + inc ) % HTSize;
       inc = inc + 2;
   }

   if (HTable[hashIndex] == rec && indexStatusList[hashIndex]== 1)
       found = true;
   else
       found = false;
   return pCount;
}

template <class elemType>
void hashT<elemType>::remove(const elemType& rec)
{
int hashIndex = hashFunction ( rec ) ;
int pCount = 0;
int inc = 1;
  
while(HTable[hashIndex] != rec && pCount < HTSize / 2)
   {
       if (indexStatusList[hashIndex] == 0)
           break;
       pCount++;
       hashIndex = (hashIndex + inc ) % HTSize;
       inc = inc + 2;
   }
   if (HTable[hashIndex] == rec)
   {
       HTable[hashIndex] = NULL;
       indexStatusList[hashIndex] = -1;
       length--;
   }
else
{
cout << "Item missing" << endl;
}

}

template <class elemType>
string hashT<elemType>::print() const
{
for (int i = 0; i < HTSize; i++){
       if (indexStatusList[i] == 1){
       cout <<HTable[i]<< " " << endl;
       }  
}   
}

template <class elemType>
hashT<elemType>::~hashT()
{
delete [] HTable;
delete [] indexStatusList;
}

Answer 1

CODE :

template <class elemType>
string hashT<elemType>::print() const
{
   ostringstream oss;
   for (int i = 0; i < HTSize; i++){
if (indexStatusList[i] == 1){
        oss<<HTable[i]<<" ";
}
   }
   return oss.str();
}