// IG17 2004-05
// Multiconjunto.cpp
// 9-2-2005

// Solucion del problema 1a del examen de Programacion Avanzada del 25/1/2005

#include <iostream>
using namespace std;

#include "Multiconjunto.h"

Multiconjunto::Nodo::Nodo(int d, int c, Nodo *s)
  : dato(d), contador(c), sig(s) {
}

void Multiconjunto::Vaciar() {
  while (primero != NULL) {
    Nodo *aux = primero;
    primero = primero->sig;
    delete aux;
  }
}

Multiconjunto::Multiconjunto() : primero(NULL) {
}

Multiconjunto::Multiconjunto(const Multiconjunto & mc) : primero(NULL) {
  *this = mc;
}

Multiconjunto & Multiconjunto::operator= (const Multiconjunto & mc) {
  if (this != &mc) {
    Vaciar();
    // La copia queda en el orden inverso, pero el orden no importa en esta clase.
    // Si interesase conservar el orden, hariamos p. ej. lo mismo que en Pila.cpp.
    for (Nodo *aux = mc.primero; aux != NULL; aux = aux->sig)
      primero = new Nodo (aux->dato, aux->contador, primero);
  }
  return *this;
}

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

int Multiconjunto::Contar(int d) const {
  for (Nodo *aux = primero; aux != NULL; aux = aux->sig)
    if (aux->dato == d)
      return aux->contador;
  return 0;
}

Multiconjunto & Multiconjunto::Insertar(int d) {
  for (Nodo *aux = primero; aux != NULL; aux = aux->sig)
    if (aux->dato == d) {
      aux->contador++;
      return *this;
    }
  primero = new Nodo(d, 1, primero);
  return *this;
}


Multiconjunto Multiconjunto::operator- (int d) const {
  Multiconjunto resultado;
  for (Nodo *aux = primero; aux != NULL; aux = aux->sig)
    if (aux->dato != d)
      resultado.primero = new Nodo (aux->dato, aux->contador,
				    resultado.primero);
  return resultado;
}

Multiconjunto Multiconjunto::operator- (const Multiconjunto & mc) const {
  Multiconjunto resultado;
  for (Nodo *aux = primero; aux != NULL; aux = aux->sig)
    if (mc.Contar(aux->dato) == 0)
      resultado.primero = new Nodo (aux->dato, aux->contador,
				    resultado.primero);
  return resultado;
  
}

Multiconjunto & Multiconjunto::operator-= (int d) {
  return *this = *this - d;
}

Multiconjunto & Multiconjunto::operator-= (const Multiconjunto & mc) {
  return *this = *this - mc;
}

bool Multiconjunto::operator== (const Multiconjunto & mc) const {
  int cantidadNodos1 = 0, cantidadNodos2 = 0;
  for (Nodo *aux = primero; aux != NULL; aux = aux->sig) {
    cantidadNodos1++;
    if (mc.Contar(aux->dato) != aux->contador)
      return false;
  }
  for (Nodo *aux = mc.primero; aux != NULL; aux = aux->sig)
    cantidadNodos2++;
  if (cantidadNodos2 != cantidadNodos1)
      return false;
  return true;  
}

void Multiconjunto::Ver() const {
  cout << "{";
  for (Nodo *aux = primero; aux != NULL; aux = aux->sig) {
    cout << aux->dato << ":" << aux-> contador;
    if (aux->sig != NULL) cout << ", ";
  }
  cout << "}" << endl;
}