Foro de elhacker.net

tam := 0
MIENTRAS !pila.vacia HACER
    pila.pop // quitar el elemento del tope
    tam := tam + 1 // sumar uno al tamaño de la pila
FIN MIENTRAS 

Funcion tamRecursivo(Pila pila):int
INICIO
    SI pila.vacia HACER // El caso base (el que termina la recursividad): si la pila esta vacia...
        return 0 // devuelve un 0 
    // Si no esta vacia...
    SINO HACER // No hace falta este <else> ya que antes hay un return. Lo pongo para que lo entiendas mejor
        pila.pop // Quitamos un elemento a la pila
        return 1 + tamRecursivo(pila) // Y devolvemos un 1 + el tamaño de la pila al haber quitado un elemento
    FIN SI
FIN 

void Pila::Copiar(const Pila &p)
{
  Pila p1;
  int i = 0;
  while (!p.Vacia()) //Vacia devuelve true si la cima == -1
  {
    p1.Apilar(p.Cimapila());
    p.Desapilar();
    i++;
   }
}

const Pila& Pila::operator= (const Pila & p)
{
    Vaciar(); //vacía la pila objeto
    Copiar(p); //copia la p en la pila objeto.
    Return p;
}

void Pila::Vaciar()
{
  while(!Vacia())
    Desapilar();
}

void Pila::Copiar(Pila p)
{
  Pila aux;
  while (!p.Vacia())
  {
    aux.Apilar(p.Cimapila());
    p.Desapilar();
  }
  while (!aux.Vacia())
  {
    Apilar(aux.Cimapila());
    aux.Desapilar();
  }
}

void Pila::Apilar(int n)
{
    accesos++;
    
    if (cima >= max)
        throw Pilallena();
    else
    {
      cima ++;
      v[cima] = n;
    }
        
}

void Pila::Desapilar()
{
    accesos++;
    
    if (cima == -1)
        throw Pilavacia();
    else
        cima--;
}

int Pila::Cimapila() 
{
    int res;
    v[cima] = res;
    accesos++;
    
    return res;
}

Pila::Pila()
{
    cima = -1;
    max = 3;
    accesos = 0;
    
    v = new int[max];
    
}

Pila::Pila (const Pila & p)
{
  cima = -1;
  Copiar(p);
}

Pila::~Pila()
{
  Vaciar();
}

 const Pila& Pila::operator= (const Pila & p)
{
  delete[] v;
  v = new int[max];
  Copiar(p);
  return p;
}

 void Pila::Copiar(Pila p)
{
  v = new int [max];
  for (int i = 0; i < p.cima; i++)
    v[i] = p.v[i];
}

Pila::Pila()
{
    cima = -1;
    max = 10;
    accesos = 0;
    
    v = new int[max]; 
    
}

Pila::Pila(int n)
{
    cima = -1;
    max = n;
    accesos = 0;
    
    v = new int[max];
    
}

Pila::Pila (const Pila & p)
{
  cima = -1;
  max = 10;
  accesos = 0;
  v = new int[p.max];
  Copiar(p);
}

Pila::~Pila()
{
  delete[] v;
}

void Pila::Copiar(Pila p)
{
  delete [] v;
  v = new int [p.max];
  for (int i = 0; i <= p.cima; i++)
  {
    cima++;
    v[i] = p.v[i];
  }
}

const Pila& Pila::operator= (const Pila & p)
{
  cout << "Se ejecuta la sobrecarga" << endl;
  Copiar(p);
  return p;
}