4 a girl I admire...

zoo.cpp

#include <iostream>
#include <cstring>
using namespace std;


/****** Taxonomia Animal ***************
*
*  Ciencia que estudia la clasificacion
*  de los seres vivos.
*
*  Clasificacion va de lo general a lo
*  especifico:
*
*  Reino
*  Filum
*  Clase
*  Orden
*  Familia
*  Genero
*  Especie
*
****************************************/

// Arbol del zoologico

/*

Reino  ----------- A
                    \     Filum     Clase    Orden     (Y asi continua)
                     B  --------- E ---------- H ------- N
                      \            \            \
                       \            \            N -------- O
                        \            \            \
                         \            F_____ I     O ---------- P
                          \
                           C ---------- G ----- J
                            \            \
                             \            H ----- K
                              \            \
                               \            I ----- L
                                \
                                 D ---------- J ----- M


Arbol Binario

Izquierda --> Siguiente conjunto
Derecha --> Subconjunto

        A
      /   \
     C     B

En el que B representa la siguiente especificacion taxonomica para
la misma clasificacion y en el que C representa la siguiente
clasificacion bajo la taxonomia actual de recorrido.

Este arbol se recorre de derecha a izquierda.

*/

struct Animal {
  string mote;  // nombre de pila
  string nombre; // nombre cientifico
  string reino;
  string filum;
  string clase;
  string orden;
  string familia;
  string genero;
  string especie;
  int existencia;
  struct Animal *izq;
  struct Animal *der;
};

struct User {
  string nombre;
  int edad;
  string proced; // procedencia
  struct User *sig;
};

typedef struct Animal *anim;
typedef struct User *user;


anim get_animal(void);
user get_user(void);


void insertar_animal(anim &initzoo) {
  anim zoo = initzoo;
  anim animal = get_animal();
  while(true) {
    if(zoo->especie == animal->especie) {
      zoo->mote = animal->mote;
      zoo->nombre = animal->nombre;
      zoo->reino = animal->reino;
      zoo->filum = animal->filum;
      zoo->clase = animal->clase;
      zoo->orden = animal->orden;
      zoo->familia = animal->familia;
      zoo->genero = animal->genero;
      zoo->especie = animal->especie;
      zoo->existencia = animal->existencia;
      zoo->izq = NULL;
      zoo->der = NULL;
      break;
    } else if(zoo->reino.empty()) {
      zoo->reino = animal->reino;
    } else {
      if(zoo->reino != animal->reino) {
        if(!zoo->izq) {
          zoo->izq = new(struct Animal);
          zoo->izq->reino = animal->reino;
          zoo->izq->izq = NULL;
          zoo->izq->der = NULL;
        }
        zoo = zoo->izq;  
      } else {
        if(!zoo->der) {
          zoo->der = new(struct Animal);
          zoo->der->reino = zoo->reino;
          zoo->der->izq = NULL;
          zoo->der->der = NULL;
        }
        zoo = zoo->der;
        if(zoo->filum.empty()) {
          zoo->filum = animal->filum;
        } else {
          if(zoo->filum != animal->filum) {
            if(!zoo->izq) {
              zoo->izq = new(struct Animal);
              zoo->izq->reino = zoo->reino;
              zoo->izq->filum = animal->filum;
              zoo->izq->izq = NULL;
              zoo->izq->der = NULL;
            }
            zoo = zoo->izq;
          } else {
            if(!zoo->der) {
              zoo->der = new(struct Animal);
              zoo->der->reino = zoo->reino;
              zoo->der->filum = zoo->filum;
              zoo->der->izq = NULL;
              zoo->der->der = NULL;
            }
            zoo = zoo->der;
            if(zoo->clase.empty()) {
              zoo->clase = animal->clase;
            } else {
              if(zoo->clase != animal->clase) {
                if(!zoo->izq) {
                  zoo->izq = new(struct Animal);
                  zoo->izq->reino = zoo->reino;
                  zoo->izq->filum = zoo->filum;
                  zoo->izq->clase = animal->clase;
                  zoo->izq->izq = NULL;
                  zoo->izq->der = NULL;
                }
                zoo = zoo->izq;
              } else {
                if(!zoo->der) {
                  zoo->der = new(struct Animal);
                  zoo->der->reino = zoo->reino;
                  zoo->der->filum = zoo->filum;
                  zoo->der->clase = zoo->clase;
                  zoo->der->izq = NULL;
                  zoo->der->der = NULL;
                }
                zoo = zoo->der;
                if(zoo->orden.empty()) {
                  zoo->orden = animal->orden;
                } else {
                  if(zoo->orden != animal->orden) {
                    if(!zoo->izq) {
                      zoo->izq = new(struct Animal);
                      zoo->izq->reino = zoo->reino;
                      zoo->izq->filum = zoo->filum;
                      zoo->izq->clase = zoo->clase;
                      zoo->izq->orden = animal->orden;
                      zoo->izq->izq = NULL;
                      zoo->izq->der = NULL;
                    }
                    zoo = zoo->izq;
                  } else {
                    if(!zoo->der) {
                      zoo->der = new(struct Animal);
                      zoo->der->reino = zoo->reino;
                      zoo->der->filum = zoo->filum;
                      zoo->der->clase = zoo->clase;
                      zoo->der->orden = zoo->orden;
                      zoo->der->izq = NULL;
                      zoo->der->der = NULL;
                    }
                    zoo = zoo->der;
                    if(zoo->familia.empty()) {
                      zoo->familia = animal->familia;
                    } else {
                      if(zoo->familia != animal->familia) {
                        if(!zoo->izq) {
                          zoo->izq = new(struct Animal);
                          zoo->izq->reino = zoo->reino;
                          zoo->izq->filum = zoo->filum;
                          zoo->izq->clase = zoo->clase;
                          zoo->izq->orden = zoo->orden;
                          zoo->izq->familia = animal->familia;
                          zoo->izq->izq = NULL;
                          zoo->izq->der = NULL;
                        }
                        zoo = zoo->izq;
                      } else {
                        if(!zoo->der) {
                          zoo->der = new(struct Animal);
                          zoo->der->reino = zoo->reino;
                          zoo->der->filum = zoo->filum;
                          zoo->der->clase = zoo->clase;
                          zoo->der->orden = zoo->orden;
                          zoo->der->familia = zoo->familia;
                          zoo->der->izq = NULL;
                          zoo->der->der = NULL;
                        }
                        zoo = zoo->der;
                        if(zoo->genero.empty()) {
                          zoo->genero = animal->genero;
                        } else {
                          if(zoo->genero != animal->genero) {
                            if(!zoo->izq) {
                              zoo->izq = new(struct Animal);
                              zoo->izq->reino = zoo->reino;
                              zoo->izq->filum = zoo->filum;
                              zoo->izq->clase = zoo->clase;
                              zoo->izq->orden = zoo->orden;
                              zoo->izq->familia = zoo->familia;
                              zoo->izq->genero = animal->genero;
                              zoo->izq->izq = NULL;
                              zoo->izq->der = NULL;
                            }
                            zoo = zoo->izq;
                          } else {
                            if(!zoo->der) {
                              zoo->der = new(struct Animal);
                              zoo->der->reino = zoo->reino;
                              zoo->der->filum = zoo->filum;
                              zoo->der->clase = zoo->clase;
                              zoo->der->orden = zoo->orden;
                              zoo->der->familia = zoo->familia;
                              zoo->der->genero = zoo->genero;
                              zoo->der->izq = NULL;
                              zoo->der->der = NULL;
                            }
                            zoo = zoo->der;
                            if(zoo->especie.empty()) {
                              zoo->especie = animal->especie;
                            } else if(zoo->especie != animal->especie) {
                              if(!zoo->izq) {
                                zoo->izq = new(struct Animal);
                                zoo->izq->reino = zoo->reino;
                                zoo->izq->filum = zoo->filum;
                                zoo->izq->clase = zoo->clase;
                                zoo->izq->orden = zoo->orden;
                                zoo->izq->familia = zoo->familia;
                                zoo->izq->genero = zoo->genero;
                                zoo->izq->especie = animal->especie;
                                zoo->izq->izq = NULL;
                                zoo->izq->der = NULL;
                              }
                              zoo = zoo->izq;
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}


user insertar_user(user &initusuarios) {
  user visitor = get_user();
  if(initusuarios->nombre.empty()) {
    visitor->sig = NULL;
  } else {
    visitor->sig = initusuarios;
  }
  return visitor;
}


user get_user() {
  user new_user = new(struct User);
  cout<<"Nombre: ";
  getline(cin, new_user->nombre);
  getline(cin, new_user->nombre);
  cout<<"Edad: ";
  cin>>new_user->edad;
  cout<<"Procedencia: ";
  getline(cin, new_user->proced);
  getline(cin, new_user->proced);

  return new_user;
}

anim get_animal() {
  anim new_animal = new(struct Animal);
  cout<<"Nombre cientifico: ";
  getline(cin, new_animal->nombre);
  getline(cin, new_animal->nombre);
  cout<<"Nombre de pila: ";
  getline(cin, new_animal->mote);
  cout<<"\n---Taxonomia---"<<endl;
  cout<<"Reino: ";
  getline(cin, new_animal->reino);
  cout<<"Filum: ";
  getline(cin, new_animal->filum);
  cout<<"Clase: ";
  getline(cin, new_animal->clase);
  cout<<"Orden: ";
  getline(cin, new_animal->orden);
  cout<<"Familia: ";
  getline(cin, new_animal->familia);
  cout<<"Genero: ";
  getline(cin, new_animal->genero);
  cout<<"Especie: ";
  getline(cin, new_animal->especie);
  cout<<"Poblacion: ";
  cin>>new_animal->existencia;
  new_animal->izq = NULL;
  new_animal->der = NULL;
  return new_animal;
}



int get_main_menu(void) {
  int op = 0;
  do {
    cout<<"\t\tZOO\nMENU PRINCIPAL\n\
    \t1. Zoologia\n\
    \t2. Visitantes\n\
    \t3. Salir\n\
    Opcion: ";
    cin>> op;
  } while(op < 1 || op > 3);
  return op;
}

int get_zoo_menu() {
  int op = 0;
  do {
    cout<<"\t\tZOO\nMENU ZOOLOGIA\n\
    \t1. Mostrar animales\n\
    \t2. Agregar especie\n\
    \t3. Editar taxonomia\n\
    \t4. Volver\n\
    Opcion: ";
    cin>> op;
  } while(op < 1 || op > 4);
  return op;
}


int get_users_menu() {
  int op = 0;
  do {
    cout<<"\t\tZOO\nMENU VISITANTES\n\
    \t1. Mostrar visitantes\n\
    \t2. Agregar visitante\n\
    \t3. Eliminar ultimo visitante\n\
    \t4. Volver\n\
    Opcion: ";
    cin>> op;
  } while(op < 1 || op > 4);
  return op;
}

void print_animals(anim &zoo) {
  if(zoo->reino.empty()) {
    cout<<"No hay datos que mostrar!"<<endl;
    return ;
  }
  if(!zoo->especie.empty()) {
    cout<<"\n------------------------------\n";
    cout<<zoo->nombre<<" ("<<zoo->mote<<"): "<<zoo->existencia<<endl;
    if(!zoo->izq) {
      return ;
    } else {
      print_animals(zoo->izq);
    }
  } else {
    print_animals(zoo->der);
    if(zoo->izq) {
      print_animals(zoo->izq);
    }
  }
}

void print_users(user &visitor) {
  if(visitor->nombre.empty()) {
    cout<<"No hay datos para mostrar!"<<endl;
    return ;
  }
  if(!visitor->sig) {
    cout<<"\n-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_\n";
    cout<<visitor->nombre<<", "<<visitor->edad<<" - "<<visitor->proced;
  } else {
    print_users(visitor->sig);
  }
}


void delete_animal(anim &zoo, string search, anim &ant) {
  if(!zoo || zoo->reino.empty()) {
    cout<<"No hay datos que buscar!"<<endl;
    return ;
  } else {
    if(!zoo->especie.empty()) {
      if(zoo->nombre == search) {
        string op;
        cout<<"Desea eliminar el archivo de "<<zoo->nombre<<"? (s/n): ";
        getline(cin, op);
        if(op == "s" || op == "si" || op == "S") {
          if(!ant->especie.empty() && ant->izq == zoo) {
            ant->izq = zoo->izq;
          }
          zoo = NULL;
        }
        return ;
      } else {
        if(zoo->izq) {
          delete_animal(zoo->izq, search, zoo);
        }
      }
    } else {
      if(zoo->der) {
        delete_animal(zoo->der, search, zoo);
      }
      if(zoo->izq) {
        delete_animal(zoo->izq, search, zoo);
      }
    }
  }
}

string get_search() {
  string query;
  cout<<"Nombre cientifico a buscar: ";
  getline(cin, query);
  return query;
}

void delete_user(user &visitor) {
  if(!visitor || visitor->nombre.empty()) {
    cout<<"No hay visitantes!"<<endl;
  }
  string op;
  cout<<"Desea eliminar el archivo de "<<visitor->nombre<<"? (s/n): ";
  getline(cin, op);
  if(op == "s" || op == "si" || op == "S") {
  user aux = visitor;
  visitor = aux->sig;
  aux = NULL;
  }
}

int main(void) {
  anim zoo = new(struct Animal);
  user users = new(struct User);

  do {
    switch(get_main_menu()) {
      case 1: // zoologico
        switch(get_zoo_menu()) {
          case 1: // mostrar animales
            print_animals(zoo);
            break;
          case 2: // agregar animal
            insertar_animal(zoo);
            break;
          case 3: // eliminar animal
            delete_animal(zoo, get_search(), zoo);
            break;
          default: break;
        }
        break;
      case 2: //usuarios
        switch(get_users_menu()) {
          case 1: // mostrar usuarios
            print_users(users);
            break;
          case 2: // agregar usuario
            users = insertar_user(users);
            break;
          case 3: // eliminar ultimo usuario
            delete_user(users);
            break;
          default: break;
        }
        break;
      case 3: // salir
        exit(0);
        break;
    }
  } while(true);
  return 0;
}