Tabela Hash com colisão do tipo lista em C++ usando classe

HashColisaoLista.cpp

// Tabela HASH com tratamento de colisões do tipo lista
// Criado por: profa. Divani Barbosa Gavinier
// Curriculo Lattes: http://lattes.cnpq.br/8503400830635447
// divanibarbosa@gmail.com

#include <iostream>
#include <math.h>
using namespace std;
////////////////////////////////////////////////
struct NO {
   double item;
   NO *prox; // proximo no da lista
};
//////////////////////////////////////////////////
class ListaSE {
  private: NO *primeiro; // ref. primeiro No
  private: NO *ultimo; // ref. ultimo No

  public: ListaSE() { primeiro = ultimo = NULL; }  // Construtor
  
  public: bool vazio()         { return (primeiro==NULL);  }

  public: void insere_lista(double valor) {
     NO *lista = new NO; // Alocando memoria para o Nó
     lista->item = valor;
     lista->prox = primeiro;
     primeiro = lista; // insere no inicio da lista
  }   
  
  public: bool pesquisa_lista(double chave) {
    NO *atual = primeiro;
    while (atual != NULL) {  // caminhando para o fim da lista
      if(atual->item == chave) return true;
      atual = atual->prox;
    }
    return false;
  }

  public: void imprime_lista() {
    NO *atual = primeiro;
    while (atual != NULL) {   // caminhando para o fim da lista
      cout << atual->item << " -> ";
      atual = atual->prox;
    }
  } 

  public: void apaga_lista(double valor) {  
    NO *atual, *anterior;
    atual = anterior = primeiro;
    while (atual != NULL) { // caminhando para o fim da lista
      if (atual->item == valor) break;
      anterior = atual;
      atual = atual->prox;
    }
    if (atual == NULL) return;
    if (atual == primeiro) { primeiro = primeiro->prox;
                             anterior = NULL;
    }
    else if (atual == ultimo) { ultimo = anterior;
                                ultimo->prox = NULL;
         }
         else anterior->prox = atual->prox;
    delete atual; 
  }

};
//////////////////////////////////////////////////
class HashLista {
  private: ListaSE *tab;
  private: bool *ocupado;
  private: int tam_max;
  
  public: HashLista(int n) {
    tab = new ListaSE[n];
    ocupado = new bool[n];
    tam_max = n;
    for(int i=0; i<n; i++) ocupado[i] = false;
  }  
  
  private: int funcaohash(double chave) {
     int v = (int) chave;
     return ( abs(v) % tam_max );
  }
  
  public: void insere(double chave) {
    int pos = funcaohash(chave);
    if (tab[pos].pesquisa_lista(chave)) { // pesquisa na lista
         cout << " Item " << chave << " duplicado (já cadastrado)\n";
         return; // se o item foi encontrado na lista ? saída imediata
    }
    tab[pos].insere_lista(chave); // insere item na lista
    if ( !ocupado[pos] ) ocupado[pos] = true;
  }
  
  public: void apaga(double chave) {
    int pos = busca(chave);
    if (pos == -1) cout << "\n Item nao encontrado\n";
    else tab[pos].apaga_lista(chave);
  }

  public: void imprime() {
    for (int i=0; i<tam_max; i++) { 
       cout << "\n HASH[" << i << "] -> ";
       if ( ocupado[i] ) tab[i].imprime_lista();
       cout << "NULL";
    }
  }

  public: int busca(double chave) {
    int pos = funcaohash(chave);
    if ( tab[pos].pesquisa_lista(chave) ) return pos;
    return -1;
  }

}; // fim classe HashLista
////////////////////////////////////////////////
main() {
    HashLista tab(7);
    double item;
    cout << "\n**************************************************\n";
    cout << "Tabela HASH colisão Lista (vetor tamanho 7)\n";
    cout << "**************************************************\n";
    cout << " Inserindo 10 elementos \n";
    for (int i=0; i<10; i++){
	cout << " Inserindo elemento " << (i+1) ;
	cout << " - Forneca valor real: ";
	cin >> item;
	tab.insere(item);
    }
    cout << "\n Imprimindo conteudo"; tab.imprime();    
    while(true) {
      cout << "\n\n>> Forneca o item que deseja apagar (-1 sai): ";
      cin >> item;
      if (item == -1) break;
      tab.apaga(item);
      tab.imprime();
    }
    cout << endl << endl;
} // fim programa principal