arbol binario

[karmi]

como eliminar un elemento de mi arbol......

Código (c) [Seleccionar] Expandir


#include <iostream.h>
#include <windows.h>
#include <conio.h>

struct Nodo
{
Nodo *izq;
int dato;
Nodo *der;
};

class arbolbinario
{
private:
Nodo *raiz;
public:
arbolbinario()
{
raiz=NULL;
}
void insertar(int d)
{
Nodo *nuevo;
nuevo = new Nodo();
nuevo->izq= NULL;
nuevo->dato=d;
nuevo->der=NULL;

if (raiz==NULL)
{
raiz=nuevo;
}
else
{
Nodo *temp, *a;
int b=0;
temp = raiz;
a = NULL;
while(temp!=NULL)
{
a = temp;
if(nuevo->dato<temp->dato)
{
temp = temp->izq;
b=1;
}
else if (nuevo->dato>temp->dato)
{
temp = temp->der;
b=2;
}
}
if (b==1)
{
a->izq=nuevo;
}
else if (b==2)
{
a->der=nuevo;
}
}

}

void MostrarIn()
{
Nodo *temp;
temp = raiz;
MostrarInorden (temp);
}
void MostrarInorden(Nodo *T)
{
if (T!=NULL)
{
MostrarInorden(T->izq);
cout << T->dato << endl;
MostrarInorden(T->der);
}
}
void MostrarPr()
{
Nodo *temp;
temp = raiz;
MostrarPreorden (temp);
}
void MostrarPreorden(Nodo *T)
{
if (T!=NULL)
{
cout << T->dato << endl;
MostrarPreorden(T->izq);
MostrarPreorden(T->der);
}
}



   void eliminar();
    ****************
};

void main (void)
{
arbolbinario numeros;
int op, n;
do
{
system("cls");
cout << "A R B O L   B I N A R I O" << endl<<endl;
cout << "1.- Insertar nodo"<< endl;
cout << "2.- Mostrar inorden"<< endl;
cout << "3.- Mostrar preorden"<< endl;
cout << "4.- Mostrar postorden"<< endl;
cout << "5.- Salir"<< endl << endl;

cout << "Elige una opcion-> ";
cin >> op;

system("cls");
switch(op)
{
case 1:
cout << "Introduce el numero: ";
cin >> n;
numeros.insertar(n);
break;
case 2:
cout << "Inorden"<<endl;
numeros.MostrarIn();
break;
case 3:
cout << "Preorden"<<endl;
numeros.MostrarPr();
break;
case 4:
cout << "Postorden"<<endl;

break;
default:

cout << "Bye!!!"<<endl;
}
getch();
}while(op>=1 && op<=4);

}


[darkraider]

No es por nada, pero yo usaría recursión porque aporta claridad al código. Y es mucho más compacto. Ya se: es más facil de depurar iterativo... pero bue...

Código (c) [Seleccionar] Expandir


#include <iostream.h>

class arbolBin
{
private:
arbolBin *iz, *dr;
int elem;
public:
arbolBin()
{
iz = NULL;
dr = NULL;
}

arbolBin(int e)
{
arbolBin();
this.elem = e;
}

bool insertar(int e)
{
if(e < elem) // sin repeticion
{
if(iz != NULL) iz->insertar(e);
else iz = new arbolBin(e);
}
else if(e > elem)
{
if(dr != NULL) dr->insertar(e);
else dr = new arbolBin(e);
}
else return false;
return true;
}

// yo devolvería una lista en vez de usar streams...
void inorden()
{
// inorden...
if(iz != NULL) iz->inorden();
cout << this.elem << " ";
if(dr != NULL) dr->inorden();
}
void preorden()
{
// preorden...
cout << this.elem << " ";
if(iz != NULL) iz->preorden();
if(dr != NULL) dr->preorden();

}
void postorden()
{
// postorden...
if(iz != NULL) iz->postorden();
if(dr != NULL) dr->postorden();
cout << this.elem << " ";
}
}


Salu2

[ANTÓN RAMIREZ]

Algunas operaciones que se les puede implementar aun arbol binario.

Código [Seleccionar] Expandir

using namespace std;

struct NODO{
int dato;
struct NODO *izq;
struct NODO *der;
};

void crearArbol(NODO **cabeza);
void insertar(NODO **cabeza, int elemento);
void inorder(NODO *cabeza), preorder(NODO *cabeza);
void postorder(NODO *cabeza);
NODO *eliminar(NODO *cabeza, int elemento);

int main()
{
   char opcion;
   int elemento;
   NODO *borrado, *raiz;
   clrscr();
   crearArbol(&raiz);
   //raiz=NULL;
   
   for(;;){
      system("cls");
      printf("\tARBOLES BINARIOS DE BUSQUEDA\n\n");
      printf("(0) SALIR\n(1) Insertar\n(2) Eliminar\n(3) Inorder\n(4) Preorder\n(5) Postorder\n");
      printf("\n\tDigite su opcion ---> ");
     
      switch(opcion=getche()){
         case '0':
            exit(0);
         case '1':
            system("cls");
            printf("\nIngrese elemento a insertar: ");
            scanf("%d", &elemento);
            insertar(&raiz, elemento);
            break;
         
         case '2':
            if(raiz==NULL){
               printf("\nNo hay nodos en al arbol\n\n");
               break;
            }
            else{
               printf("\nIngrese dato a eliminar: ");
               scanf("%d", & elemento);
               borrado=eliminar( raiz, elemento);
               if(borrado==NULL)
                  printf("\nDato no encontrado\n\n");
               break;
            }         
         case '3':
            system("cls");
            printf("\nEl arbol es: ");
            inorder(raiz);
            system("pause");
            break;
         case '4':
            system("cls");
            printf("\nEl arbol es: ");
            preorder(raiz);
            break;
         case '5':
            system("cls");
            printf("\nEl arbol es: ");
            postorder(raiz);
            break;
      }
      printf("\n\n");
   }


   system("pause");
   return(0);
}
void crearArbol(NODO **cabeza)
{
   *cabeza=NULL;   
}
void insertar(NODO **cabeza, int elemento)
{

   if(*cabeza==NULL){
      *cabeza= (NODO *) malloc(sizeof(NODO));
     
      if(*cabeza==NULL){
         printf("No hay memoria\n");
         return;
      }     
      (*cabeza)->dato=elemento;
      (*cabeza)->izq=NULL;
      (*cabeza)->der=NULL;
   }
   else
      if(elemento< (*cabeza)->dato)
         insertar(& (*cabeza)->izq, elemento);
      else
         if(elemento> (*cabeza)->dato)
            insertar(& (*cabeza)->der, elemento);
         else
            printf("\nNo puede insertar: valor duplicado\n\n");

}

NODO *eliminar(NODO *cabeza, int elemento)
{
   NODO *p, *p2;
   
   if(elemento==cabeza->dato){
      if(cabeza->izq==cabeza->der){
         free(cabeza);
         return(NULL);
      }
     
      else
         if(cabeza->izq==NULL){
            p=cabeza->der;
            free(cabeza);
            return(p);
         }
     
         else
            if(cabeza->der==NULL){
               p=cabeza->izq;
               free(cabeza);
               return(p);
            }     
            else{
               p2=cabeza->der;
               p=cabeza->der;
               while(p->izq) p=p->izq;
                  p->izq=cabeza->izq;
               free(cabeza);
               return(p2);
            }
   }
   
   if(cabeza->dato<elemento)
      cabeza->der=eliminar(cabeza->der, elemento);
   else
      cabeza->izq=eliminar(cabeza->izq, elemento);
   return(cabeza);
}


void inorder(NODO *cabeza)
{
   if(cabeza!=NULL){
      inorder(cabeza->izq);
      printf("%d ",cabeza->dato);
      inorder(cabeza->der);
   }
}

void preorder(NODO *cabeza)
{
   if(cabeza!=NULL){
      printf("%d ", cabeza->dato);
      preorder(cabeza->izq);
      preorder(cabeza->der);
   }
}

void postorder(NODO *cabeza)
{
   if(cabeza!=NULL){
      postorder(cabeza->izq);
      postorder(cabeza->der);
      printf("%d ",cabeza->dato);
   }
}
void salvar(NODO **cabeza, int elemento)
{
   NODO *p, *p2;
   if(elemento==cabeza->dato){
      if(cabeza->izq==cabeza->der){
         free(cabeza);
         return(NULL);
      }
   if (elemento > 0){
      if ()
         moverDrcha(actual, k);
      else
         combina(actual, k);

   else /* Sólo tiene "hermano" derecho */
      if (actual->ramas[1]->cuenta > m/2)
         moverIzqda(actual, 1);
      else
         combina(actual, 1);
}[/color]