Error LNK2005 and error LNK1169 multiple definition in Visual Studio 16.7.0 2019 Release x64 Win10 Pro 2004

Question

Some code was written by me, the rest by my partner and his last partner. I'm working with a partner whom also does not fully understand the code as his last partner did some of it. He still understands it more than I do.

Removed MyForm.cpp/MyForm.h, unimplemented code and comments because of character limit. The MyForm.cpp includes the MyForm.h and the Funciones.cpp and calls the Windows Form in main. MyForm.h is a GUI that I will scrap later for a Python embedded GUI. The unimplemented code can be fixed with alt + enter and having VS create a definition.

Funciones.cpp

#include <fstream>
#include <sstream>
#include <iostream>
#include <string>
#include <thread>
#include <map>
#include <cstdlib>
#include <cstring>
#include <stdlib.h>
#include <conio.h>
#include <errno.h>
#include <math.h>

using namespace std;

struct nodoAA
{
    int cont, nivel;
    int codSede;
    int codCarrera;
    int codCurso;
    int codGrupo;
    string nombreAA;
    int cantCupos;

    nodoAA* derAA;
    nodoAA* izqAA;
    nodoAA* padre;
    nodoAA* siguiente;
    nodoAA* raizAA;

    friend class NodoBinario;
    friend class RBArbol;
}*raizAA;

class AA_Arbol
{
public:
    int buscar(int, int, int, int, string, int);
    void girar(nodoAA*);
    bool dividir(nodoAA*);
    void balancear(nodoAA*);
    nodoAA* insertar(nodoAA*, nodoAA*);
    void print(nodoAA*);
    int contarN(nodoAA*);
    void PreordenAA(nodoAA*);
    void PostordenAA(nodoAA*);
    void InordenAA(nodoAA*, int);
    void PreordenAAXCurso(int, nodoAA*);
    nodoAA* BuscarGrupoAA(nodoAA*, int, int, int, int);
    nodoAA* getRaizAA();
    void setRaizAA(nodoAA*);
    AA_Arbol() { raizAA = NULL; }
};
nodoAA* AA_Arbol::getRaizAA()
{
    return raizAA;
}

void AA_Arbol::setRaizAA(nodoAA* raizAA)
{
    raizAA = raizAA;
    return;
}

nodoAA* AA_Arbol::BuscarGrupoAA(nodoAA* temp, int codigo1, int codigo2, int codigo3, int codigo4)
{
    if (temp == NULL)
        return NULL;
    else if (temp->codSede == codigo1 && temp->codCarrera == codigo2 && temp->codCurso == codigo3 && temp->codGrupo == codigo4)
        return temp;
    else if (temp->codGrupo > codigo4)
        return BuscarGrupoAA(temp->izqAA, codigo1, codigo2, codigo3, codigo4);
    else if (temp->codGrupo < codigo4)
        return BuscarGrupoAA(temp->derAA, codigo1, codigo2, codigo3, codigo4);
    else
        return NULL;
}

int AA_Arbol::buscar(int codSede, int codCarrera, int codCurso, int codGrupo, string nombreAA, int cantCupos)
{
    nodoAA* temp = new nodoAA();
    temp->codSede = codSede;
    temp->codCarrera = codCarrera;
    temp->codCurso = codCurso;
    temp->codGrupo = codGrupo;
    temp->nombreAA = nombreAA;
    temp->cantCupos = cantCupos;
    temp->nivel = 1;
    temp->cont = 0;
    temp->izqAA = NULL;
    temp->derAA = NULL;
    temp->padre = NULL;
    temp = insertar(raizAA, temp);
    return temp->cont;
}

void AA_Arbol::girar(nodoAA* temp)
{
    nodoAA* ptr = temp->izqAA;

    if (temp->padre->izqAA == temp)
        temp->padre->izqAA = ptr;
    else
        temp->padre->derAA = ptr;

    ptr->padre = temp->padre;
    temp->padre = ptr;
    temp->izqAA = ptr->derAA;

    if (temp->izqAA != NULL)
        temp->izqAA->padre = temp;
    ptr->derAA = temp;
    temp->nivel = (temp->izqAA ? temp->izqAA->nivel + 1 : 1); //(expresión relacional) ? (expresion1) : (expresion2)  |   true : false se ejecuta
}

bool AA_Arbol::dividir(nodoAA* temp)
{
    nodoAA* ptr = temp->derAA;

    if (ptr && ptr->derAA && (ptr->derAA->nivel == temp->nivel))
    {
        if (temp->padre->izqAA == temp)
            temp->padre->izqAA = ptr;
        else
            temp->padre->derAA = ptr;

        ptr->padre = temp->padre;
        temp->padre = ptr;
        temp->derAA = ptr->izqAA;

        if (temp->derAA != NULL)
            temp->derAA->padre = temp;

        ptr->izqAA = temp;
        ptr->nivel = temp->nivel + 1;
        return true;
    }
    return false;
}

void AA_Arbol::balancear(nodoAA* temp)
{
    temp->izqAA = NULL;
    temp->derAA = NULL;
    temp->nivel = 1;
    for (temp = temp->padre; temp != raizAA; temp = temp->padre)
    {
        if (temp->nivel != (temp->izqAA ? temp->izqAA->nivel + 1 : 1))
        {
            girar(temp);

            if (temp->derAA == NULL)
                temp = temp->padre;
            else if (temp->nivel != temp->derAA->nivel)
                temp = temp->padre;
        }

        if (temp->padre != raizAA)
        {
            if (dividir(temp->padre) == false)
                break;
        }
    }
}

nodoAA* AA_Arbol::insertar(nodoAA* temp, nodoAA* ins)
{
    if (raizAA == NULL)
    {
        ins->cont = 1;
        ins->padre = NULL;
        ins->izqAA = NULL;
        ins->derAA = NULL;
        raizAA = ins;
        return raizAA;
    }

    if (ins->codGrupo < temp->codGrupo)
    {
        if (temp->izqAA)
            return insertar(temp->izqAA, ins);

        temp->izqAA = ins;
        ins->padre = temp;
        ins->cont = 1;
        balancear(ins);
        return ins;
    }

    if (ins->codGrupo > temp->codGrupo)
    {
        if (temp->derAA)
            return insertar(temp->derAA, ins);
        temp->derAA = ins;
        ins->padre = temp;
        ins->cont = 1;
        balancear(ins);
        return ins;
    }

    temp->cont++;

    delete ins;
    return temp;
}

void AA_Arbol::print(nodoAA* temp)
{
    if (!temp)
        return;

    print(temp->izqAA);
    cout << "Valor: " << temp->codGrupo << "  Cont:" << temp->cont;
    cout << "  nivel: " << temp->nivel << endl;
    print(temp->derAA);
}

int AA_Arbol::contarN(nodoAA* temp)
{
    if (!temp)
        return 0;

    int cont = 1;
    cont = cont + contarN(temp->izqAA);
    cont = cont + contarN(temp->derAA);
    return cont;
}

void AA_Arbol::PreordenAA(nodoAA* temp)
{
    if (temp == NULL)
        return;
    else
    {
        cout << "Codigo de grupo: " << temp->codGrupo << ", " << "nombreAA: " << temp->nombreAA << " - ";
        PreordenAA(temp->izqAA);
        PreordenAA(temp->derAA);
    }
}

void AA_Arbol::InordenAA(nodoAA* temp, int n)
{
    if (temp == NULL)
        return;
    else
    {
        InordenAA(temp->izqAA, n);
        if (temp->codCurso == n)
        {
            cout << ".Codigo de grupo: " << temp->codGrupo << ", " << "Nombre: " << temp->nombreAA << ", " << "Cantidad de Cupos: " << temp->cantCupos << endl;
            InordenAA(temp->derAA, n);
        }
        else
        {
            InordenAA(temp->derAA, n);
        }
    }
}

void AA_Arbol::PostordenAA(nodoAA* temp)
{
    if (temp == NULL)
        return;
    else
    {
        PostordenAA(temp->izqAA);
        PostordenAA(temp->derAA);
        cout << "Codigo de grupo: " << temp->codGrupo << ", " << "nombreAA: " << temp->nombreAA << " - ";
    }
}

void AA_Arbol::PreordenAAXCurso(int CodCurso, nodoAA* temp)
{
    if (temp == NULL)
        return;
    else
    {
        if (CodCurso == temp->codCurso)
            cout << "Codigo de grupo: " << temp->codGrupo << ", " << "Nombre: " << temp->nombreAA << ", " << "Cupos: " << temp->cantCupos << " - " << endl;

        PreordenAAXCurso(CodCurso, temp->izqAA);
        PreordenAAXCurso(CodCurso, temp->derAA);
    }
}

enum Color { ROJO, NEGRO };

struct Nodo
{
    int codigoSede;
    int codigoCarrera;
    int codigoCurso;
    string nombreRN;
    int creditos;    //CodSede;CodCarrera;CodCurso;Nombre;Creditos
    bool color;
    Nodo* izqRN, * derRN, * padreRN, * siguiente;
    nodoAA* siguiente3 = NULL;

    // Constructor 
    Nodo(int codigoSede, int codigoCarrera, int codigoCurso, string nombreRN, int creditos)
    {
        this->codigoSede = codigoSede;
        this->codigoCarrera = codigoCarrera;
        this->codigoCurso = codigoCurso;
        this->nombreRN = nombreRN;
        this->creditos = creditos;
        izqRN = derRN = padreRN = NULL;
        this->color = ROJO;
    }
    friend class NodoBinario;
};

//Class arbol ROJO-NEGRO 
class RBArbol
{
public:
    Nodo* raizRN;

    void rotarizqRN(Nodo*&, Nodo*&);
    void rotarderRN(Nodo*&, Nodo*&);
    void reglaDelTio(Nodo*&, Nodo*&);

    // Constructor 
    RBArbol() { raizRN = NULL; }
    void insertar(const int& n, const int& n2, const int& n3, const string& n4, const int& n5);
    void inordenRN(int n);
    Nodo* BuscarCursoRNMod(Nodo*, int);
    Nodo* BuscarCursoRN(Nodo* raizRN, int, int, int);
    void BuscarCursoRNRep(Nodo*, int);
    Nodo* getRaiz();
    void setRaiz(Nodo* raizRN);
};

Nodo* RBArbol::getRaiz()
{
    return raizRN;
}

void RBArbol::setRaiz(Nodo* raizRN)
{
    raizRN = raizRN;
    return;
}

Nodo* RBArbol::BuscarCursoRNMod(Nodo* raizRN, int codigo)
{
    if (raizRN == NULL)
        return NULL;
    else if (raizRN->codigoCurso == codigo)
        return raizRN;
    else if (raizRN->codigoCurso > codigo)
        return BuscarCursoRNMod(raizRN->izqRN, codigo);
    else if (raizRN->codigoCurso < codigo)
        return BuscarCursoRNMod(raizRN->derRN, codigo);
}

void RBArbol::BuscarCursoRNRep(Nodo* raizRN, int codigo)
{
    if (raizRN == NULL)
        return;
    else
    {
        if (raizRN->codigoCarrera == codigo)
            cout << "\nCodigo de Curso:" << raizRN->codigoCurso << " | Nombre: " << raizRN->nombreRN << " | Creditos: " << raizRN->creditos;

        BuscarCursoRNRep(raizRN->izqRN, codigo);
        BuscarCursoRNRep(raizRN->derRN, codigo);
    }
}

Nodo* RBArbol::BuscarCursoRN(Nodo* raizRN, int codigo1, int codigo2, int codigo3)
{
    if (raizRN == NULL)
        return NULL;
    else if (raizRN->codigoSede == codigo1 && raizRN->codigoCarrera == codigo2 && raizRN->codigoCurso == codigo3)
        return raizRN;
    else if (raizRN->codigoCurso > codigo3)
        return BuscarCursoRN(raizRN->izqRN, codigo1, codigo2, codigo3);
    else if (raizRN->codigoCurso < codigo3)
        return BuscarCursoRN(raizRN->derRN, codigo1, codigo2, codigo3);
    else
        return NULL;
}

void inorderRNHelper(Nodo* raizRN, int n)
{
    if (raizRN == NULL)
        return;

    inorderRNHelper(raizRN->izqRN, n);
    if (raizRN->codigoCarrera == n)
    {
        cout << ".Codigo de Curso: " << raizRN->codigoCurso << ", " << "Nombre: " << raizRN->nombreRN << ", " << "Creditos: " << raizRN->creditos << endl;
        inorderRNHelper(raizRN->derRN, n);
    }
    else
        inorderRNHelper(raizRN->derRN, n);
}

Nodo* BSTInsertar(Nodo* raizRN, Nodo* pt)
{
    if (raizRN == NULL)
        return pt;

    if (pt->codigoCurso <= raizRN->codigoCurso)
    {
        raizRN->izqRN = BSTInsertar(raizRN->izqRN, pt);
        raizRN->izqRN->padreRN = raizRN;
    }
    else if (pt->codigoCurso > raizRN->codigoCurso)
    {
        raizRN->derRN = BSTInsertar(raizRN->derRN, pt);
        raizRN->derRN->padreRN = raizRN;
    }
    return raizRN;
}

void RBArbol::rotarizqRN(Nodo*& raizRN, Nodo*& pt)
{
    Nodo* pt_derRN = pt->derRN;

    pt->derRN = pt_derRN->izqRN;

    if (pt->derRN != NULL)
        pt->derRN->padreRN = pt;

    pt_derRN->padreRN = pt->padreRN;

    if (pt->padreRN == NULL)
        raizRN = pt_derRN;

    else if (pt == pt->padreRN->izqRN)
        pt->padreRN->izqRN = pt_derRN;

    else
        pt->padreRN->derRN = pt_derRN;

    pt_derRN->izqRN = pt;
    pt->padreRN = pt_derRN;
}

void RBArbol::rotarderRN(Nodo*& raizRN, Nodo*& pt)
{
    Nodo* pt_izqRN = pt->izqRN;

    pt->izqRN = pt_izqRN->derRN;

    if (pt->izqRN != NULL)
        pt->izqRN->padreRN = pt;

    pt_izqRN->padreRN = pt->padreRN;

    if (pt->padreRN == NULL)
        raizRN = pt_izqRN;

    else if (pt == pt->padreRN->izqRN)
        pt->padreRN->izqRN = pt_izqRN;

    else
        pt->padreRN->derRN = pt_izqRN;

    pt_izqRN->derRN = pt;
    pt->padreRN = pt_izqRN;
}

void RBArbol::reglaDelTio(Nodo*& raizRN, Nodo*& pt)
{
    Nodo* padreRN_pt = NULL;
    Nodo* abuelo_pt = NULL;
    while ((pt != raizRN) && (pt->color != NEGRO) && (pt->padreRN->color == ROJO))
    {
        padreRN_pt = pt->padreRN;
        abuelo_pt = pt->padreRN->padreRN;
        /*  Case : A
            padreRN de pt es hijo izqRN de abuelo pt*/
        if (padreRN_pt == abuelo_pt->izqRN)
        {
            Nodo* tio_pt = abuelo_pt->derRN;

            /* Case : 1
               Pone el tio en rojo*/
            if (tio_pt != NULL && tio_pt->color == ROJO)
            {
                abuelo_pt->color = ROJO;
                padreRN_pt->color = NEGRO;
                tio_pt->color = NEGRO;
                pt = abuelo_pt;
            }
            else
            {
                /* Case : 2
                el hijo derRNecho de la raizRN hacer rotacion izqRNuierda */
                if (pt == padreRN_pt->derRN)
                {
                    rotarizqRN(raizRN, padreRN_pt);
                    pt = padreRN_pt;
                    padreRN_pt = pt->padreRN;
                }
                /* Case : 3
                pt hijo izqRNuierdo del papa hacer rotacion derRNecha y cambia a rojo */
                rotarderRN(raizRN, abuelo_pt);
                swap(padreRN_pt->color, abuelo_pt->color);
                pt = padreRN_pt;
            }
        }
        /* Case : B
           padreRN of pt es el hijo derRNecho del abuelo de pt */
        else
        {
            Nodo* tio_pt = abuelo_pt->izqRN;

            /*  Case : 1
            el tio de pt es tambien rojo  */
            if ((tio_pt != NULL) && (tio_pt->color == ROJO))
            {
                abuelo_pt->color = ROJO;
                padreRN_pt->color = NEGRO;
                tio_pt->color = NEGRO;
                pt = abuelo_pt;
            }
            else
            {
                /* Case : 2
                pt hijo izqRN del padreRN hace rotacion derRNecha y cambia a rojo */
                if (pt == padreRN_pt->izqRN)
                {
                    rotarderRN(raizRN, padreRN_pt);
                    pt = padreRN_pt;
                    padreRN_pt = pt->padreRN;
                }
                /* Case : 3
                pt is el hijo derRNecho del padreRN y hace rotacion izqRN*/
                rotarizqRN(raizRN, abuelo_pt);
                swap(padreRN_pt->color, abuelo_pt->color);
                pt = padreRN_pt;
            }
        }
    }
    raizRN->color = NEGRO;
}

void RBArbol::insertar(const int& codigoSede, const int& codigoCarrera, const int& codigoCurso, const string& nombreRN, const int& creditos)
{
    Nodo* pt = new Nodo(codigoSede, codigoCarrera, codigoCurso, nombreRN, creditos);
    raizRN = BSTInsertar(raizRN, pt);
    reglaDelTio(raizRN, pt);
}

void RBArbol::inordenRN(int n)
{
    inorderRNHelper(raizRN, n);
}

class NodoBinario
{
public:

    NodoBinario(int num, int num2, string nombre, int num3, NodoBinario* der = NULL, NodoBinario* izq = NULL, NodoBinario* sig = NULL) :
        Hizq(izq), Hder(der), valor(num), valor2(num2), name(nombre), cantCursos(num3), siguiente(sig), FB(0) {}

    int valor;
    int valor2;
    string name;
    int cantCursos;
    int FB;
    NodoBinario* Hizq, * Hder, * siguiente;
    Nodo* siguiente2 = NULL;
    friend class Pila;
    friend class Binario;

    void InsertaBinario(int num, int num2, string nombre, int num3);
};

typedef NodoBinario* pnodo;
typedef NodoBinario* pNodoBinario;
typedef NodoBinario*& pNodoBinario2;

class Binario
{
public:
    pNodoBinario raiz;

    Binario() :raiz(NULL) {}

    void InsertaNodo(int num, int num2, string nombre, int num3);
    void PreordenR(pNodoBinario raiz);
    void InordenR(pNodoBinario raiz);
    void PostordenR(pNodoBinario raiz);
    void PreordenAVL(pNodoBinario raiz);
    void InordenAVL(pNodoBinario raiz, int);
    void PostordenAVL(pNodoBinario raiz);
    NodoBinario* BuscarSede(pNodoBinario raiz, int);
    void PreordenAVLXSede(int, NodoBinario* R);
    NodoBinario* BuscarCarrera(pNodoBinario raiz, int, int);
    //void evaluar();

    bool Hh;

    void Borrar(NodoBinario* nodoB, bool);
    void BorrarBalanceado(NodoBinario* r, bool, int eliminar);
    void Equilibrar1(NodoBinario* n, bool);
    void Equilibrar2(NodoBinario* n, bool);
    void InsertarBalanceado(NodoBinario*& r, bool&, int x, int  x2, string nombre, int x3);
    void RotacionDobleIzquierda(NodoBinario*& n1, NodoBinario* n2);
    void RotacionDobleDerecha(NodoBinario*& n1, NodoBinario* n2);
    void RotacionSimpleIzquierda(NodoBinario*& n1, NodoBinario* n2);
    void RotacionSimpleDerecha(NodoBinario*& n1, NodoBinario* n2);
};

void NodoBinario::InsertaBinario(int num, int num2, string nombre, int num3)
{
    if (num < valor)
    {
        if (Hizq == NULL)
            Hizq = new NodoBinario(num, num2, nombre, num3);
        else
            Hizq->InsertaBinario(num, num2, nombre, num3);
    }
    else if (num > valor)
    {
        if (Hder == NULL)
            Hder = new NodoBinario(num, num2, nombre, num3);
        else
            Hder->InsertaBinario(num, num2, nombre, num3);
    }
}

void Binario::InsertaNodo(int num, int num2, string nombre, int num3)
{
    if (raiz == NULL)
        raiz = new NodoBinario(num, num2, nombre, num3);
    else
        raiz->InsertaBinario(num, num2, nombre, num3);
}

void Binario::PreordenR(NodoBinario* R)
{
    if (R == NULL)
        return;
    else
    {
        cout << ".Codigo de Sede: " << R->valor << ", " << "Nombre: " << R->name << endl;
        PreordenR(R->Hizq);
        PreordenR(R->Hder);
    }
}

void Binario::InordenR(NodoBinario* R)
{
    if (R == NULL)
        return;
    else {
        InordenR(R->Hizq);
        cout << ".Codigo de Sede: " << R->valor << ", " << "Nombre: " << R->name << endl;
        InordenR(R->Hder);
    }
}

void Binario::PostordenR(NodoBinario* R)
{
    if (R == NULL)
        return;
    else
    {
        PostordenR(R->Hizq);
        PostordenR(R->Hder);
        cout << ".Codigo de Sede: " << R->valor << ", " << "Nombre: " << R->name << endl;
    }
}

void Binario::PreordenAVL(NodoBinario* R)
{
    if (R == NULL)
        return;
    else
    {
        cout << ".Codigo de carrera: " << R->valor << ", " << "Nombre: " << R->name << "Cantidad de Cursos: " << R->cantCursos << endl;
        PreordenAVL(R->Hizq);
        PreordenAVL(R->Hder);
    }
}

void Binario::InordenAVL(NodoBinario* R, int codigo)
{
    if (R == NULL)
        return;
    else
    {
        InordenAVL(R->Hizq, codigo);
        if (R->valor2 == codigo)
        {
            cout << ".Codigo de carrera: " << R->valor << ", " << "Nombre: " << R->name << ", " << "Cantidad de Cursos: " << R->cantCursos << endl;
            InordenAVL(R->Hder, codigo);
        }
        else
            InordenAVL(R->Hder, codigo);
    }
}

void Binario::PostordenAVL(NodoBinario* R)
{
    if (R == NULL)
        return;
    else
    {
        PostordenAVL(R->Hizq);
        PostordenAVL(R->Hder);
        cout << ".Codigo de carrera: " << R->valor << ", " << "Nombre: " << R->name << ", " << "Cantidad de Cursos: " << R->cantCursos << endl;
    }
}

NodoBinario* Binario::BuscarSede(pNodoBinario R, int codigo)
{
    if (R == NULL)
        return NULL;
    else if (R->valor == codigo)
        return R;
    else if (R->valor > codigo)
        return BuscarSede(R->Hizq, codigo);
    else if (R->valor < codigo)
        return BuscarSede(R->Hder, codigo);
    else
        return NULL;
}

void Binario::PreordenAVLXSede(int CodSede, NodoBinario* R)
{
    if (R == NULL)
        return;
    else
    {
        if (CodSede == R->valor2)
        {
            cout << "\nCodigo de carrera: " << R->valor << ", " << "Nombre: " << R->name << "Cantidad de Cursos: " << R->cantCursos << endl;
            cout << "\n";
        }
        PreordenAVLXSede(CodSede, R->Hizq);
        PreordenAVLXSede(CodSede, R->Hder);
    }
}

NodoBinario* Binario::BuscarCarrera(pNodoBinario R, int codigo1, int codigo2)
{
    if (R == NULL)
        return NULL;
    else if ((R->valor == codigo2) & (R->valor2 == codigo1))
        return R;
    else if (R->valor > codigo2)
        return BuscarCarrera(R->Hizq, codigo1, codigo2);
    else if (R->valor < codigo2)
        return BuscarCarrera(R->Hder, codigo1, codigo2);
    else
        return NULL;
}

void Binario::InsertarBalanceado(pNodoBinario2 ra, bool& Hh, int x, int x2, string nombre, int x3)
{
    pNodoBinario n1;
    if (ra == NULL)
    {
        ra = new NodoBinario(x, x2, nombre, x3);
        Hh = true;
    }
    else
    {
        if (x < ra->valor)
        {
            InsertarBalanceado(ra->Hizq, Hh, x, x2, nombre, x3);
            if (Hh)
            {
                switch (ra->FB)
                {  //ra->valor asi estaba antes 
                case 1: ra->FB = 0;
                    Hh = false;
                    break;
                case 0: ra->FB = -1;
                    break;
                case -1: n1 = ra->Hizq;
                    if (n1->FB == -1)
                        RotacionSimpleIzquierda(ra, n1);
                    else
                        RotacionDobleIzquierda(ra, n1);
                    Hh = false;
                    break;
                }
            }
        }
        else
        {
            if (x > ra->valor)
            {
                InsertarBalanceado(ra->Hder, Hh, x, x2, nombre, x3);

                if (Hh)
                {
                    switch (ra->FB)
                    {
                    case -1: ra->FB = 0;
                        Hh = false;
                        break;
                    case 0: ra->FB = 1;
                        break;
                    case 1: n1 = ra->Hder;
                        if (n1->FB == 1)
                            RotacionSimpleDerecha(ra, n1);
                        else
                            RotacionDobleDerecha(ra, n1);
                        Hh = false;
                        break;
                    }
                }
            }
        }
    }
}

void Binario::RotacionDobleIzquierda(pNodoBinario2 n, NodoBinario* n1)
{
    NodoBinario* n2;
    n2 = n1->Hder;
    n->Hizq = n2->Hder;
    n2->Hder = n;
    n1->Hder = n2->Hizq;
    n2->Hizq = n1;

    if (n2->FB == 1)
        n1->FB = -1;
    else
        n1->FB = 0;

    if (n2->FB == -1)
        n->FB = 1;
    else
        n->FB = 0;

    n2->FB = 0;
    n = n2;
}

void Binario::RotacionDobleDerecha(pNodoBinario2 n, NodoBinario* n1)
{
    NodoBinario* n2;
    n2 = n1->Hizq;
    n->Hder = n2->Hizq;
    n2->Hizq = n;
    n1->Hizq = n2->Hder;
    n2->Hder = n1;

    if (n2->FB == 1)
        n->FB = -1;
    else
        n->FB = 0;

    if (n2->FB == -1)
        n1->FB = 1;
    else
        n1->FB = 0;

    n2->FB = 0;
    n = n2;
}

void Binario::RotacionSimpleDerecha(pNodoBinario2 n, NodoBinario* n1)
{
    n->Hder = n1->Hizq;
    n1->Hizq = n;

    if (n1->FB == 1)
    {
        n->FB = 0;
        n1->FB = 0;
    }
    else
    {
        n->FB = 1;
        n1->FB = -1;
    }
    n = n1;
}

void Binario::RotacionSimpleIzquierda(pNodoBinario2 n, NodoBinario* n1)
{
    n->Hizq = n1->Hder;
    n1->Hder = n;

    if (n1->FB == -1)
    {
        n->FB = 0;
        n1->FB = 0;
    }
    else
    {
        n->FB = -1;
        n1->FB = -1;
    }
    n = n1;
}

class Pagina
{
public:
    Pagina()
    {
        for (int i = 0; i < 5; i++)
        {
            clave[i] = -1;
            Nombres[i] = -1;
        }
        for (int i = 0; i < 5; i++)
        {
            rama[i] = NULL;
        }
        cuenta = 0;
    }
    int clave[5];
    string Nombres[5];
    Pagina* rama[5];
    int cuenta;
    static const int max = 4;
    static const int min = 2;
    friend class ArbolB;
};

class ArbolB
{
public:
    Pagina* raiz;
    ArbolB() { raiz = NULL; }
    void BuscarNodo(int c1, Pagina*& p, bool& encontrado, int& k);
    void InsertarArbolB(int c1, string Nom, Pagina*& raiz);
    void Empujar(int c1, string Nom, Pagina*& r, bool& empujarArriba, int& mdna, Pagina*& xr);
    void MeterHoja(int x, string Nom, Pagina*& xder, Pagina*& p, int& k);
    void DividirNodo(int x, string Nom, Pagina* xder, Pagina*& p, int& k, int& mdna, Pagina*& mder);
    bool verCarnet(int x, Pagina* r);
    void Burbuja(Pagina*& r);
    Pagina* BuscarE(int x, Pagina* r);
    bool arbolBVacio() { return raiz == NULL; }
};

class nodo {
public:
    //nodos estudiante
    nodo(string codSede, string pNombre)
    {
        codigo_sede = codSede;
        nombre = pNombre;
        siguiente = NULL;
        anterior = NULL;
        abajo = NULL;
    }

    nodo(int pCarnet, string pNombre, string codSede, int pCursos)
    {
        carnet = pCarnet;
        nombre = pNombre;
        codigo_sede = codSede;
        cursos = pCursos;
        siguiente = NULL;
        anterior = NULL;
        arriba = NULL;
        abajo = NULL;
    }

    nodo(string codSede, string codCarrera, string codCurso, string codGrupo, int pCantCreditos)
    {
        codigo_sede = codSede;
        codigo_carrera = codCarrera;
        codigo_curso = codCurso;
        codigo_grupo = codGrupo;
        creditos = pCantCreditos;
        siguiente = NULL;
        anterior = NULL;
        arriba = NULL;
        abajo = NULL;
    }

    string codigo_sede;
    string codigo_carrera;
    string codigo_curso;
    string codigo_grupo;
    string nombre;
    string cantCursos;
    string cantCreditos;
    int cantCupos;
    int carnet;
    int creditos;
    int cursos;
    nodo* siguiente;
    nodo* anterior;
    nodo* arriba;
    nodo* abajo;
};
typedef nodo* pnodo_enlazado;

void ArbolB::BuscarNodo(int c1, Pagina*& p, bool& encontrado, int& k)
{
    if (c1 < p->clave[1])
    {
        encontrado = false;
        k = 0;
    }
    else
    {
        k = p->cuenta;
        while ((c1 < p->clave[k]) && (k > 1))
        {
            k = k - 1;
        }
        if (c1 == p->clave[k])
            encontrado = true;
        else
            encontrado = false;
    }
}

void ArbolB::InsertarArbolB(int c1, string Nom, Pagina*& raiz)
{//ya esta  
    int x;
    Pagina* xr;
    Pagina* p;
    bool empujarArriba = false;
    Empujar(c1, Nom, raiz, empujarArriba, x, xr);
    if (empujarArriba)
    {
        p = new Pagina();
        p->cuenta = 1;
        p->clave[1] = x;
        p->Nombres[1] = Nom;
        p->rama[0] = raiz;
        p->rama[1] = xr;
        raiz = p;
    }
}

void ArbolB::Empujar(int c1, string Nom, Pagina*& r, bool& empujarArriba, int& mdna, Pagina*& xr)
{
    bool encontrado = false;
    int k = 0;
    if (r == NULL)
    {
        empujarArriba = true;
        mdna = c1;
        xr = NULL;
    }
    else
    {
        BuscarNodo(c1, r, encontrado, k);
        //this->Burbuja(r);
        if (encontrado)
            cout << "Elemento Repetido";

        Empujar(c1, Nom, r->rama[k], empujarArriba, mdna, xr);
        if (empujarArriba)
        {
            if (r->cuenta < Pagina().max)
            {
                empujarArriba = false;
                MeterHoja(mdna, Nom, xr, r, k);
            }
            else
            {
                empujarArriba = true;
                DividirNodo(mdna, Nom, xr, r, k, mdna, xr);
            }
        }
    }
}

void ArbolB::MeterHoja(int x, string Nom, Pagina*& xder, Pagina*& p, int& k)
{
    for (int i = p->cuenta; i >= k + 1; i--)
    {
        p->clave[i + 1] = p->clave[i];
        p->Nombres[i + 1] = p->Nombres[i];
        p->rama[i + 1] = p->rama[i];
    }
    p->clave[k + 1] = x;
    p->Nombres[k + 1] = Nom;
    p->rama[k + 1] = xder;
    p->cuenta = p->cuenta + 1;
}

void ArbolB::Burbuja(Pagina*& r)
{
    int aux;
    string auxN;
    for (int i = 1; i < r->cuenta + 1; i++)
    {
        for (int j = 1; j < r->cuenta; j++)
        {
            if (raiz->clave[j] > raiz->clave[j + 1] && raiz->clave[j + 1] != -1)
            {
                aux = raiz->clave[j];
                auxN = raiz->Nombres[j];

                raiz->clave[j] = raiz->clave[j + 1];
                raiz->clave[j + 1] = aux;

                raiz->Nombres[j] = raiz->Nombres[j + 1];
                raiz->Nombres[j + 1] = auxN;
            }
        }
    }
}

void ArbolB::DividirNodo(int x, string Nom, Pagina* xder, Pagina*& p, int& k, int& mdna, Pagina*& mder)
{
    int posmda;
    if (k <= Pagina().min)
        posmda = Pagina().min;
    else
        posmda = Pagina().min + 1;

    mder = new Pagina();
    for (int i = posmda + 1; i <= Pagina().max; i++)
    {
        mder->clave[i - posmda] = p->clave[i];
        mder->Nombres[i - posmda] = p->Nombres[i];
        mder->rama[i - posmda] = p->rama[i];
    }
    mder->cuenta = Pagina().max - posmda;
    p->cuenta = posmda;
    if (k <= Pagina().min)
        MeterHoja(x, Nom, xder, p, k);
    else
    {
        k = k - posmda;
        MeterHoja(x, Nom, xder, mder, k);
    }
    mdna = p->clave[p->cuenta];
    mder->rama[0] = p->rama[p->cuenta];
    p->cuenta = p->cuenta - 1;
}

bool ArbolB::verCarnet(int x, Pagina* r)
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (r->clave[j] == x)
                return true;
        }
        if (r->rama[i] != NULL)
        {
            if (verCarnet(x, r->rama[i]) == true)
                return true;
        }
    }
    return false;
}

Pagina* ArbolB::BuscarE(int x, Pagina* r)
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (r->clave[j] == x)
                return r;
        }
        if (r->rama[i] != NULL)
        {
            if (BuscarE(x, r->rama[i]) == r)
                return r;
        }
    }
    return NULL;
}

class listaDC {
public:
    listaDC() { primero = NULL; }
    bool listaVacia() { return primero == NULL; }
    int largoLista();
    void InsertaMatricula(string pCarnet, string nombre);
    bool verificar(string sede, string carrera, string curso, string grupo, int id, int creditos, int& verificar);
    void Eliminar(string sede, string carrera, string curso, string grupo, int id, int creditos);

    pnodo_enlazado primero;

    void informeMatricula(listaDC& lista_matricula, listaDC& lista_sedes);
    void estudiantesPorSede(listaDC& lista_matricula);
    void maxEstudiantes(listaDC& lista_matricula);
    void minEstudiantes(listaDC& lista_matricula);
    void cursosPorEstudiante(listaDC& lista_matricula);
    void creditosPorEstudiante(listaDC& lista_matricula);
    void estudianteMasCursos(listaDC& lista_matricula);
};

int listaDC::largoLista()
{
    int cont = 0;
    pnodo_enlazado aux = primero;
    if (listaVacia())
        return cont;
    else
    {
        while (aux != primero)
        {
            aux = aux->siguiente;
            cont++;
        }
        return cont;
    }
}

void listaDC::InsertaMatricula(string pCarnet, string nombre)
{
    int id, cursos = 0;
    string codSede = "";
    istringstream(pCarnet) >> id;
    if (listaVacia())
    {
        primero = new nodo(id, nombre, codSede, cursos);
        primero->anterior = primero;
        primero->siguiente = primero;
    }
    else
    {
        pnodo_enlazado aux = primero;
        int verificar = 0;
        do
        {
            if (aux->carnet != id)
                aux = aux->siguiente;
            else
            {
                cout << "ERROR: Un estudiante tiene el mismo id de un estudiante ya ingresado" << endl;
                verificar++;
                aux = primero;
            }
        } while (aux != primero);
        if (verificar == 0)
        {
            pnodo_enlazado nuevo = new nodo(id, nombre, codSede, cursos);
            nuevo->anterior = primero->anterior;
            nuevo->siguiente = primero->anterior->siguiente;
            primero->anterior->siguiente = nuevo;
            primero->anterior = nuevo;
        }
    }
}

bool listaDC::verificar(string sede, string carrera, string curso, string grupo, int id, int creditos, int& verificar)
{
    pnodo_enlazado aux = primero;
    do
    {
        if (aux->carnet == id)
        {
            aux->codigo_sede = sede;
            if (aux->abajo == NULL)
            {
                pnodo_enlazado nuevo = new nodo(sede, carrera, curso, grupo, creditos);
                aux->abajo = nuevo;
                nuevo->arriba = aux;
                nuevo->anterior = nuevo;
                nuevo->siguiente = nuevo;
                aux = primero;
            }
            else
            {
                pnodo_enlazado auxInfo = aux->abajo;
                int verificar = 0;
                do
                {
                    if (auxInfo->codigo_carrera == carrera && auxInfo->codigo_curso == curso && auxInfo->codigo_grupo == grupo)
                        return false;
                    else
                        auxInfo = auxInfo->siguiente;
                } while (auxInfo->arriba == NULL);
                pnodo_enlazado nuevo = new nodo(sede, carrera, curso, grupo, creditos);
                nuevo->anterior = auxInfo->anterior;
                nuevo->siguiente = auxInfo;
                auxInfo->anterior->siguiente = nuevo;
                auxInfo->anterior = nuevo;
                aux = primero;
            }
        }
        else
            aux = aux->siguiente;
    } while (aux != primero);
    return true;
}

int ArchivoMod(string texto)
{
    ofstream out_file;
    ifstream in_file;

    // Escribir el archivo
    out_file.open("Modificaciones.txt", ios::app);
    out_file << texto << endl;
    out_file.close(); 

    return 1;
}

int ArchivoAA(string texto)
{
    ofstream out_file;
    ifstream in_file;
    
    out_file.open("AccionesAdmin.txt", ios::app);
    out_file << texto << endl;
    out_file.close(); 

    return 1;
}