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;
}