bool abb_asignar(abb_t* arbol, nodo_t* nodo, const char* clave, void* dato){
if (arbol->funcion_de_comparacion(clave,nodo->clave) == 0){
nodo->dato = dato;
return true;
}
if(arbol->funcion_de_comparacion(clave,nodo->clave)>0){
if(!nodo->nodo_derecho){ //cmp si devuelve 0 son iguales
nodo_t* nodo_auxiliar = crear_nodo(); // - si el primero menor
nodo_auxiliar->clave = strdup(clave); // + si el primero mayor
if(!nodo_auxiliar->clave)return false;
nodo_auxiliar->dato = dato;
nodo->nodo_derecho= nodo_auxiliar;
arbol->cantidad++;
return true;
}
else{
return abb_asignar(arbol,nodo->nodo_derecho,clave,dato);
}
}
else{
if (!nodo->nodo_izquierdo){
nodo_t* nodo_auxiliar = crear_nodo();
nodo_auxiliar->clave = strdup(clave);
nodo_auxiliar->dato = dato;
nodo->nodo_izquierdo = nodo_auxiliar;
arbol->cantidad++;
return true;
}
else{
return abb_asignar(arbol,nodo->nodo_izquierdo,clave,dato);
}
}
}
void insertar(int nodo, int dato){
if(clave[nodo]>dato){
if(izq[nodo] == -1){
izq[nodo] = crear_nodo(dato);
} else {
insertar(izq[nodo], dato);
}
} else {
if(der[nodo] == -1){
der[nodo] = crear_nodo(dato);
} else {
insertar(der[nodo], dato);
}
}
}
bool abb_guardar(abb_t *arbol, const char *clave, void *dato){
if (!arbol->raiz){
nodo_t* raiz = crear_nodo();
arbol->raiz = raiz;
arbol->raiz->clave = strdup(clave);
arbol->raiz->dato = dato;
arbol->cantidad++;
return true;
}
return abb_asignar(arbol,arbol->raiz,clave,dato);
}
int main(){
int i,num;
int array[1005];
scanf("%d",&N);
for(i=0; i<N; ++i){
scanf("%d",&array[i]);
}
for(i=N-1; i>=0; --i){
if(i==(N-1)){
raiz = crear_nodo(array[i]);
} else {
insertar(raiz, array[i]);
}
}
preorden(raiz);
return 0;
}
// Agrega un nuevo elemento al principio de la lista. Devuelve falso
// men caso de error.
// Pre: la lista fue creada.
// Post: se agregó un nuevo elemento a la lista, dato se encuentra al inicio
// de la lista.
bool lista_insertar_primero(lista_t *lista, void *dato)
{
nodo_t* nodo_nuevo = crear_nodo(dato);
if (!nodo_nuevo)
return false;
/*Si la lista esta vacía el nodo será el primero y último de la lista. */
if (lista_esta_vacia(lista))
insertar_lista_vacia(lista, nodo_nuevo);
else{
/* Asignamos a la primer posicion al nuevo nodo */
nodo_nuevo->prox = lista->primero;
lista->primero = nodo_nuevo;
}
lista->cantidad++;
return true;
}
// Agrega un nuevo elemento al final de la lista. Devuelve falso
// en caso de error.
// Pre: la lista fue creada.
// Post: se agregó un nuevo elemento a la lista, dato se encuentra al final
// de la lista.
bool lista_insertar_ultimo(lista_t *lista, void *dato)
{
/* Creamos el nuevo nodo. */
nodo_t* nodo_nuevo = crear_nodo(dato);
if (!nodo_nuevo)
return false;
/*Si la lista esta vacía el nodo será el primero y último de la lista. */
if (lista_esta_vacia(lista))
insertar_lista_vacia(lista, nodo_nuevo);
else{
/* Obtenemos el ultimo nodo y le agregamos el nuevo nodo al miembro prox. */
lista->ultimo->prox = nodo_nuevo;
lista->ultimo = nodo_nuevo;
}
lista->cantidad++;
return true;
}
/**************************************
Agrega_nodo:
Ingresa un nodo al arbol de parsing
tomando como referencia un nodo padre.
***************************************/
void Agrega_nodo (struct Tnodo **raiz, char *nombre)
{
struct Tnodo *nodo = crear_nodo (nombre);
if (raiz == &root) {
if (root == NULL)
root = nodo;
else {
struct Tnodo *ap;
if (root->hijos == NULL){
root->hijos=nodo;
}
else{
for (ap = root; ap->siguiente != NULL; ap = ap->siguiente)
;
ap->siguiente = nodo;
} }
} else {
if(strcmp((*raiz)->nombre,nodo->nombre)==0){
if ((*raiz)->siguiente == NULL) {
(*raiz)->siguiente = nodo;
}
else {
struct Tnodo *ap;
for (ap = (*raiz)->siguiente; ap->siguiente != NULL; ap = ap->siguiente)
;
ap->siguiente = nodo;
}
}
else{
if ((*raiz)->hijos == NULL) {
(*raiz)->hijos = nodo;
}
else {
struct Tnodo *ap;
for (ap = (*raiz)->hijos; ap->siguiente != NULL; ap = ap->siguiente)
;
ap->siguiente = nodo;
}} }
}
// Inserta un nuevo elemento a la lista en la posicion del iterador,
// devuelve falso en caso de error.
// Pre: la lista y el iterador fueron creados.
// Post: se insertó un nuevo elemento en la lista.
bool lista_insertar(lista_t *lista, lista_iter_t *iter, void *dato)
{
/* Creamos una variable para verificar que, en caso de ser usadas,
* insertar_primero o insertar_ultimo funcionaron correctamente */
bool exito = true;
/* Si el iterador está al principio de la lista o la lista
* está vacía, insertamos en el primero */
if (!iter->anterior && (exito = lista_insertar_primero(lista, dato))){
iter->actual = lista->primero;
return true;
}
/* Si el iterador está al final de la lista insertamos en el ultimo */
if (lista_iter_al_final(iter) && (exito = lista_insertar_ultimo(lista, dato))){
iter->actual = lista->ultimo;
return true;
}
/* El iterador no está al final ni al principio de la lista */
if (exito){
/* Creamos el nuevo nodo con el dato a insertar */
nodo_t* nodo_nuevo = crear_nodo(dato);
if (!nodo_nuevo)
return false;
/* Ubicamos el nuevo nodo en la posicion en donde se
* encontraba el iterador, iter->actual pasa a ser el nuevo
* nodo insertado e iter->anterior se mantiene constante */
nodo_nuevo->prox = iter->actual;
iter->actual = nodo_nuevo;
iter->anterior->prox = nodo_nuevo;
lista->cantidad++;
return true;
}
/* lista_insertar_primero o lista_insertar_ultimo devolvió false */
return false;
}
nodo *poner_nodo(nodo *raiz, char *cadena)
{
// Añade un nuevo nodo
if ( raiz != NULL )
{
if ( strcmp( cadena, raiz->linea) < 0 ) // cadena es menor
raiz->izq = poner_nodo(raiz->izq, cadena);
else
raiz->der = poner_nodo( raiz->der, cadena );
}
else
{
raiz = crear_nodo();
if ((raiz->linea = (char *) malloc(strlen(cadena) + 1)) == NULL)
{
perror("poner_nodo");
exit(-1);
}
strcpy( raiz->linea, cadena );
}
return raiz;
}
int ins_avl (struct nodo **raiz,int n)
{
struct nodo *nuevo,*p,*q,*s,*pivote,*pp;
int llave,altura;
nuevo = crear_nodo(n);
if (*raiz == NULL) {
*raiz = nuevo;
return (1); /* el arbol tiene un solo nodo */
}
pp = q = NULL;
pivote = p = *raiz;
llave = nuevo->info;
while (p != NULL) {
if (p->bal) {
pp = q;
pivote = p;
}
if (llave == p->info) {
free (nuevo);
return (2); /* ya existe */
}
else {
q = p;
if (llave < p->info)
p = p->izq;
else p = p->der;
}
}
if (llave < q->info)
q->izq = nuevo;
else q->der = nuevo;
if (llave < pivote->info) {
s = pivote->izq;
altura = 1;
}
else {
s = pivote->der;
altura = -1;
}
p = s;
while (p != nuevo)
if (llave < p->info) {
p->bal = 1;
p = p->izq;
}
else {
p->bal = -1;
p = p->der;
}
if (pivote->bal == 0)
pivote->bal = altura;
else if (pivote->bal + altura == 0)
pivote->bal = 0;
else {
if (altura == 1)
if (s->bal == 1)
r_derecha (pivote,s);
else dr_derecha (pivote,&s);
else if (s->bal == -1)
r_izquierda (pivote,s);
else dr_izquierda (pivote,&s);
if (pp == NULL)
*raiz = s;
else if (pp->izq == pivote)
pp->izq = s;
else pp->der = s;
}
}
void main() {
int choice;
char ans = 'N';
int key;
Nodo *nuevo_nodo, *raiz, *tmp;
raiz = NULL;
system("clear");
printf("\nPrograma para árbol de búsqueda binaria:");
do {
printf("\n1.Insertar");
printf("\n2.Buscar");
printf("\n3.Listar árbol");
printf("\n4.Dibujar arbol");
printf("\n5.Exit");
printf("\nIndicar operación : ");
scanf("%d", &choice);
switch (choice) {
case 1:
do {
nuevo_nodo = crear_nodo(1);
printf("\nIngresar elemento : ");
scanf("%d", &nuevo_nodo->clave);
insertar(&raiz, &nuevo_nodo);
printf("\nQuiere ingresar mas elementos?(y/n) : ");
scanf(" %c", &ans);
} while (ans == 'y');
break;
case 2:
printf("\nIngresar clave a ser buscada : ");
scanf("%d", &key);
tmp = buscar(&raiz, key);
if(tmp == NULL)
printf("\nNo existe la clave en el árbol!!!");
break;
case 3:
if (raiz == NULL) {
printf("Arbol no está creado.");
} else {
printf("\nMostrar Inorder : ");
inorder(&raiz);
printf("\nMostrar Preorder : ");
preorder(&raiz);
printf("\nMostrar Postorder : ");
postorder(&raiz);
}
break;
case 4:
dibujar_arbol(raiz);
break;
}
} while (choice != 5);
}
