TABLAS DE DISPERSIÓN (HASH)

TABLAS ENCADENADAS INDIRECTAS

class EClaveErronea { }; template class TTablaAbierta; template class TNodoTabla { private: TClave _clave; TValor _valor; TNodoTabla *_sig; TNodoTabla( const TClave&, const TValor&, TNodoTabla * ); public: const TClave& clave() const; const TValor& valor() const; TNodoTabla * sig() const; friend TTablaAbierta ; };

template class TTablaAbierta { public: TTablaAbierta( ); TTablaAbierta( const TTablaAbierta & ); ~TTablaAbierta( ); TTablaAbierta & operator=( const TTablaAbierta & ); void inserta( const TClave&, const TValor& ); void borra( const TClave& ); const TValor& consulta( const TClave& ) const throw (EClaveErronea); bool esta( const TClave& ) const; bool esVacio( ) const; void escribe( ostream& salida ) const;

private: static const int longMax = 10; TNodoTabla * _espacio[longMax]; void libera(); void copia( const TTablaAbierta & ); //FUNCIÓN HASH int localiza( const TClave&) const; void busca ( const TClave&, TNodoTabla * &, TNodoTabla * & ) const; };

template TNodoTabla ::TNodoTabla( const TClave& clave, const TValor& valor, TNodoTabla * sig = 0 ) : _clave(clave), _valor(valor), _sig(sig) { }; template const TClave& TNodoTabla ::clave() const { return _clave; } template const TValor& TNodoTabla ::valor() const { return _valor; } template TNodoTabla * TNodoTabla ::sig() const { return _sig; }

template TTablaAbierta ::TTablaAbierta( ) { for ( int i = 0; i < longMax; i++ ) _espacio[i] = 0; }; template void TTablaAbierta ::busca( const TClave& clave, TNodoTabla * & act, TNodoTabla * & ant ) const { bool encontrado = false; ant = 0; while ((! encontrado) && (act != 0) ) { encontrado = clave == act->clave(); if ( ! encontrado ) { ant = act; act = act->sig(); } };

template int TTablaAbierta ::localiza( const TClave& clave) const { return clave.num() % longMax; }; template void TTablaAbierta ::inserta( const TClave& clave, const TValor& valor ) { int i; TNodoTabla *act, *ant; i = localiza( clave ); act = _espacio[i]; busca( clave, act, ant ); if ( act != 0 ) act->_valor = valor; else {//si no esta se inserta al principio act = new TNodoTabla (clave, valor, _espacio[i]); _espacio[i] = act; } };

template void TTablaAbierta ::borra( const TClave& clave ) { int i; TNodoTabla *act, *ant; i = localiza(clave); act = _espacio[i]; busca( clave, act, ant ); if ( act != 0 ) { if ( ant != 0 ) ant->_sig = act->sig(); else //estamos borrando el primero _espacio[i] = act->sig(); delete act; } };

template const TValor& TTablaAbierta ::consulta( const TClave& clave ) const throw (EClaveErronea) { int i; TNodoTabla *act, *ant; i = localiza(clave); act = _espacio[i]; busca( clave, act, ant ); if ( act == 0 ) throw EClaveErronea(); return act->valor(); };

template bool TTablaAbierta ::esta( const TClave& clave ) const { int i; TNodoTabla *act, *ant; i = localiza(clave); act = _espacio[i]; busca( clave, act, ant ); return act != 0; }; template bool TTablaAbierta ::esVacio( ) const { int i = 0; bool vacio = true; while ( vacio && (i < longMax) ) { vacio = _espacio[i] == 0; i++; } return vacio; };

TABLAS DE DIRECCIONAMIENTO ABIERTO (redispersión doble)

class EClaveErronea { }; class EDesbordamiento { }; template class TTablaCerrada; enum TPosicion {vacia, ocupada, borrada}; template class TNodoTabla { private: TClave _clave; TValor _valor; TPosicion _posicion; TNodoTabla( );

public: const TClave& clave() const; const TValor& valor() const; const TPosicion& posicion() const; friend TTablaCerrada ; }; template class TTablaCerrada { public: TTablaCerrada( ); TTablaCerrada( const TTablaCerrada & ); ~TTablaCerrada( ); TTablaCerrada & operator=( const TTablaCerrada & );

void inserta( const TClave&, const TValor& ); void borra( const TClave& ); const TValor& consulta( const TClave& ) const throw (EClaveErronea); bool esta( const TClave& ) const; bool esVacio( ) const; void escribe( ostream& salida ) const; private: static const int longMax = 23; // se recomienda primo > 20 TNodoTabla _espacio[longMax]; void libera(); void copia( const TTablaCerrada & ); int busca ( const TClave& ) const; };

template TNodoTabla ::TNodoTabla( ) : _posicion(vacia) { }; template const TClave& TNodoTabla ::clave() const { return _clave; } template const TValor& TNodoTabla ::valor() const { return _valor; } template const TPosicion& TNodoTabla ::posicion() const { return _posicion; }

template TTablaCerrada ::TTablaCerrada( ) { for ( int i = 0; i < longMax; i++ ) _espacio[i]._posicion = vacia; }; template int TTablaCerrada ::busca( const TClave& clave ) const { int i, n, d, m; bool encontrado; n = clave.num(); i = n % longMax; d = (n % (longMax-2)) + 1; m = 0; //contabiliza el número de pruebas por si la tabla está llena encontrado = false; while ( (! encontrado) && (_espacio[i].posicion() != vacia) && (m < longMax) ) { if ( _espacio[i]._posicion == ocupada ) encontrado = clave == _espacio[i].clave(); if ( ! encontrado ) { m++; i = (i + d) % longMax; } } if ( ! encontrado ) { i = longMax; }; return i; };

template void TTablaCerrada ::borra( const TClave& clave ) { int i = busca(clave); if ( i != longMax ) _espacio[i]._posicion = borrada; }; template const TValor& TTablaCerrada ::consulta( const TClave& clave ) const throw (EClaveErronea) { int i = busca(clave); if ( i == longMax ) throw EClaveErronea(); return _espacio[i].valor(); }; template bool TTablaCerrada ::esta( const TClave& clave ) const { int i = busca(clave); return i != longMax; };

template void TTablaCerrada ::inserta( const TClave& clave, const TValor& valor ) { int i, n, d, m; bool encontrado; n = clave.num(); i = n % longMax; d = (n % (longMax-2)) + 1; m = 0; //contabiliza el número de pruebas por si la tabla está llena encontrado = false; while ( ( ! encontrado ) && (_espacio[i].posicion() == ocupada) && (m < longMax) ) { if ( _espacio[i]._posicion == ocupada ) encontrado = clave == _espacio[i].clave(); if ( ! encontrado ) { m++; i = (i + d) % longMax; }

if ( m == longMax ) throw EDesbordamiento(); else if ( encontrado ) _espacio[i]._valor = valor; else if ( _espacio[i].posicion() == vacia ) {_espacio[i]._clave = clave; _espacio[i]._valor = valor; _espacio[i]._posicion = ocupada; } else if ( _espacio[i].posicion() == borrada ) { _espacio[i]._clave = clave; _espacio[i]._valor = valor; _espacio[i]._posicion = ocupada; m++; i = (i + d) % longMax; while ( ( ! encontrado ) && (_espacio[i].posicion() != vacia) && (m < longMax) ) { if ( _espacio[i].posicion() == ocupada ) encontrado = clave == _espacio[i].clave(); if ( ! encontrado ) { m++; i = (i + d) % longMax; } } if ( encontrado ) {_espacio[i]._posicion = borrada;}; } };

template bool TTablaCerrada ::esVacio( ) const { int i = 0; bool vacio = true; while ( vacio && (i < longMax) ) { vacio = _espacio[i].posicion() != ocupada; i++; } return vacio; }; template void TTablaCerrada ::escribe( ostream& salida ) const { for ( int i = 0; i < longMax; i++ ) { salida << i << ":"; if ( _espacio[i].posicion() == ocupada ) salida << "(" << _espacio[i].clave() << ", " << _espacio[i].valor()<< ")"; else if ( _espacio[i].posicion() == borrada ) salida << "###"; salida << endl; } };