---

vector_disperso.cpp

Ir a la documentación de este archivo.

#include <cassert>
#include <vector_disperso.h>

/* _________________________________________________________________________ */

bool Vector_Disperso::posicion_indice(int& pos, int i) const
{
    int izq=0, der=nelementos-1,centro;

    while (der-izq>=0) {
        centro=(izq+der)/2;
        if (i<datos[centro].indice)
        der=centro-1;
        else if (i>datos[centro].indice)
                izq=centro+1;
                else {
                pos=centro;
                return true;
                }
    }
    pos=izq;

    return false;
}


/* _________________________________________________________________________ */

void Vector_Disperso::expandir() 
{ 
  reservados= (nelementos==0)?1:nelementos*2;
  Elemento * nuevos_datos= new Elemento[reservados];
  for (int j= 0; j<nelementos ;++j)
    nuevos_datos[j]= datos[j];
  delete[] datos;
  datos= nuevos_datos;
}

/* _________________________________________________________________________ */

void Vector_Disperso::contraer() 
{ 
  assert(nelementos<=reservados/2);
  reservados= reservados/2;
  Elemento * nuevos_datos= new Elemento[reservados];
  for (int j= 0; j<nelementos ;++j)
    nuevos_datos[j]= datos[j];
  delete[] datos;
  datos= nuevos_datos;
}

/* _________________________________________________________________________ */

Vector_Disperso::Vector_Disperso()
{
  datos=0;
  nelementos=reservados=0;
  valor_por_defecto= 0.0;
}
    
/* _________________________________________________________________________ */

Vector_Disperso::Vector_Disperso(const Vector_Disperso& orig) 
{
  valor_por_defecto= orig.valor_por_defecto;
  reservados= nelementos= orig.nelementos;
  if (nelementos>0) {
    datos= new Elemento[nelementos];
    for (int i=0; i<nelementos;++i)
      datos[i]= orig.datos[i];
  }
  else datos=0;
}

/* _________________________________________________________________________ */

Vector_Disperso::~Vector_Disperso() 
{
  if (reservados>0)
    delete[] datos;
}

/* _________________________________________________________________________ */

Vector_Disperso& Vector_Disperso::operator= (const Vector_Disperso& orig) 
{
  if (this!= &orig) {
    if (reservados>0)
      delete[] datos;
    valor_por_defecto= orig.valor_por_defecto;
    reservados= nelementos= orig.nelementos;
    if (nelementos>0) {
      datos= new Elemento[nelementos];
      for (int i=0; i<nelementos;++i)
        datos[i]= orig.datos[i];
    }
    else datos=0;
  }
  return *this;
}



/* _________________________________________________________________________ */

float Vector_Disperso::get_default() const 
{
  return valor_por_defecto;
}

/* _________________________________________________________________________ */

void Vector_Disperso::set_default(float f) 
{
  assert (nelementos==0);
  valor_por_defecto= f;
}

/* _________________________________________________________________________ */

float Vector_Disperso::get(int i) const 
{
  int pos;
  if (posicion_indice(pos,i))
    return datos[pos].valor;
  else return valor_por_defecto;
}

/* _________________________________________________________________________ */

void Vector_Disperso::set(int i, float f)
{
  int pos;
  
  if (posicion_indice(pos,i)){ // Está en pos
    if (f!=valor_por_defecto)
      datos[pos].valor= f;
    else { // hay que eliminarlo
      nelementos= nelementos-1;
      for (int j=pos;j<nelementos;++j)
         datos[j]=datos[j+1];
      if (nelementos<reservados/4)
         contraer();
    }
  }
  else { // No está en el vector (estaría en pos)
    if (f!=valor_por_defecto) {
      if (nelementos==reservados)
         expandir();
      for (int j=nelementos; j>pos; --j)
         datos[j]= datos[j-1];
      datos[pos].indice= i;
      datos[pos].valor= f;
      ++nelementos;
    }
  }
}

/* _________________________________________________________________________ */

int Vector_Disperso::num_elementos() const
{
  return nelementos;
}

/* _________________________________________________________________________ */

void Vector_Disperso::datos_posicion(int i, int& indice, float& valor) const
{
  assert (0<=i && i<nelementos);
  indice= datos[i].indice;
  valor= datos[i].valor;
}

---