ESTRUCTURA PROYECTO

LIBRERIAS AVL
#define TRUE 1
#define FALSE 0


/* Estructuras y tipos */
typedef struct _nodo {
int indice;
int codigo;
int prioridad;
int tiempo;
int FE;
struct _nodo *derecho;
struct _nodo *izquierdo;
struct _nodo *padre;
} tipoNodo;

typedef tipoNodo *pNodo;
typedef tipoNodo *Arbol;

enum {IZQUIERDO, DERECHO};

/* Funciones con árboles: */

/* Insertar en árbolordenado: */
void Insertar(Arbol *a, int ind,int cod, int prio,int tie);

/* Borrar un elemento: */
void Borrar(Arbol *a, int ind);

/* Función de búsqueda: */
int Buscar(Arbol a, int ind);

/* Comprobar si el árbol está vacío: */
int Vacio(Arbol r);

/* Comprobar si es un nodo hoja: */
int EsHoja(pNodo r);

/* Contar número de nodos: */
int NumeroNodos(Arbol a, int* c);

/* Calcular la altura de unárbol: */
int AlturaArbol(Arbol a, int* altura);

/* Calcular altura de un dato: */
int Altura(Arbol a, int ind);

/* Aplicar una función a cada elemento del árbol: */
void InOrden(Arbol, void (*func)(pNodo*));
void PreOrden(Arbol, void (*func)(pNodo*));
void PostOrden(Arbol, void (*func)(pNodo*));

// Funciones de equilibrado:
void Equilibrar(Arbol *raiz, pNodo nodo, int, int);
void RSI(Arbol *raiz,pNodo indice);
void RSD(Arbol *raiz, pNodo indice);
void RDI(Arbol *raiz, pNodo indice);
void RDD(Arbol *raiz, pNodo indice);

/* Funciones auxiliares: */
void Podar(Arbol *a);
void auxContador(Arbol a, int*);
void auxAltura(Arbol a, int, int*);

void Mostrar(pNodo *muestra,int *);


/* Programa de ejemplo */





/* Poda: borrar todos los nodos a partir de uno, incluido */
void Podar(Arbol *a)
{/* Algoritmo recursivo, recorrido en postorden */
if(*a) {
Podar(&(*a)->izquierdo); /* Podar izquierdo */
Podar(&(*a)->derecho); /* Podar derecho */
free(*a); /* Eliminar nodo */
*a = NULL;
}
}

/* Insertar un dato en el árbol ABB */
void Insertar(Arbol *a, int ind,int cod, int prio,int tie)
{

pNodo padre = NULL;
pNodo actual = *a;

/*Buscar el dato en el árbol, manteniendo un puntero al nodo padre */
while(!Vacio(actual) && ind != actual->indice) {
padre = actual;
if(ind < actual->indice)
actual = actual->izquierdo;
else if(ind > actual->indice)
actual = actual->derecho;
}

/* Si se ha encontrado el elemento, regresar sin insertar */
if(!Vacio(actual)){
printf("El indice yaexiste");
return;
}
/* Si padre es NULL, entonces el árbol estaba vacío, el nuevo nodo será
el nodo raiz */
if(Vacio(padre)) {
*a = (Arbol)malloc(sizeof(tipoNodo));
(*a)->indice = ind;
(*a)->codigo = cod;
(*a)->prioridad = prio;
(*a)->tiempo = tie;
(*a)->izquierdo = (*a)->derecho = NULL;
(*a)->padre = NULL;
(*a)->FE = 0;
}
/*Si el dato es menor que el que contiene el nodo padre, lo insertamos
en la rama izquierda */
else if(ind < padre->indice) {
actual = (Arbol)malloc(sizeof(tipoNodo));
padre->izquierdo = actual;
actual->indice = ind;
actual->codigo = cod;
actual->prioridad = prio;
actual->tiempo = tie;

actual->izquierdo = actual->derecho = NULL;actual->padre = padre;
actual->FE = 0;
Equilibrar(a, padre, IZQUIERDO, TRUE);
}
/* Si el dato es mayor que el que contiene el nodo padre, lo insertamos
en la rama derecha */
else if(ind > padre->indice) {
actual = (Arbol)malloc(sizeof(tipoNodo));
padre->derecho = actual;
actual->indice = ind;
actual->codigo = cod;
actual->prioridad = prio;actual->tiempo = tie;
actual->izquierdo = actual->derecho = NULL;
actual->padre = padre;
actual->FE = 0;
Equilibrar(a, padre, DERECHO, TRUE);
}
}



/* Equilibrar árbol AVL partiendo del nodo nuevo */
void Equilibrar(Arbol *a, pNodo indice, int rama, int nuevo)
{
int salir = FALSE;

/* Recorrer camino inverso actualizando valores de FE: */
while(indice && !salir) {...