UNIVERSIDAD NACIONAL DEL ALTIPLANO

Facultad de Ingeniera Mecnica Elctrica, Electrnica y

Sistemas
Escuela Profesional de Ingeniera de Sistemas

CURSO:
INTELIGENCIA ARTIFICIAL
TRABAJO:
Tema:
Recorridos de rboles en C++
INTEGRANTES:
CHIPA CARRASCO FRANCISCO: 135564
MMANI NINA YOHEL ROMARIO:

DOCENTE:
Ing.

PUNO PER
2017
 UNA - PUNO INTELIGENCIA ARTIFICIAL

RECORRIDO SOBRE RBOLES

Recorrido en profundidad

Recorrido Pre-orden (raz, izquierdo, derecho).

Para recorrer un rbol binario no vaco en Pre-Orden,
hay que realizar las siguientes operaciones
recursivamente en cada nodo, comenzando con el
nodo de raz:
- Visite la raz
- Atraviese el sub-rbol izquierdo
- Atraviese el sub-rbol derecho
Para poder entender mejor esta definicin vemos la
siguiente imagen.

Recorrido Post-orden (izquierdo, derecho, raz).

Para recorrer un rbol binario no vaco en Post-
Orden, hay que realizar las siguientes operaciones
recursivamente en cada nodo:
- Atraviese el sub-rbol izquierdo
- Atraviese el sub-rbol derecho
- Visite la raz
Para comprender mejor esta definicin observemos
la siguiente imagen:

Recorrido in-orden (izquierdo, raz, derecho).

Para recorrer un rbol binario no vaco en In-Orden,
hay que realizar las siguientes operaciones
recursivamente en cada nodo:
- Atraviese el sub-rbol izquierdo
- Visite la raz
- Atraviese el sub-rbol derecho
Para comprender mejor esta definicin observemos
la siguiente imagen:

Recorrido en Amplitud(Anchura)
Se recorre primero la raz, luego se recorren los
dems nodos ordenados por el nivel al que
pertenecen en orden de Izquierda a derecha.
Este tipo de bsqueda se caracteriza por que la
bsqueda se hace nivel por nivel y de izquierda a
derecha.

2
 UNA - PUNO INTELIGENCIA ARTIFICIAL

IMPLEMENTANDO EN EL LENGUAJE C++

Grfico como referencia:

3
 UNA - PUNO INTELIGENCIA ARTIFICIAL

//Prototipos
#include<iostream> void menu();
#include<conio.h> Nodo *crearNodo(int,Nodo *);
#include<stdlib.h> void insertarNodo(Nodo *&,int,Nodo *);
using namespace std; void mostrarArbol(Nodo *,int);
bool busqueda(Nodo *,int);
typedef struct Nodo{ void preOrden(Nodo *);
int dato; void inOrden(Nodo *);
Nodo *der; void postOrden(Nodo *);
Nodo *izq; void Anchura(Nodo *);
Nodo *padre; Nodo *arbol = NULL;
} *ABB ;
int main(){
struct nodoCola menu();
{
ABB ptr; getch();
struct nodoCola *sgte; return 0;
}; }
struct cola{
struct nodoCola *delante; //Funcion para crear un nuevo nodo
struct nodoCola *atras; Nodo *crearNodo(int n,Nodo *padre){
}; Nodo *nuevo_nodo = new Nodo();

void inicializaCola(struct cola &q) nuevo_nodo->dato = n;

{ nuevo_nodo->der = NULL;
q.delante = NULL; nuevo_nodo->izq = NULL;
q.atras = NULL; nuevo_nodo->padre = padre;
}
return nuevo_nodo;
void encola(struct cola &q, ABB n) }
{ //Funcion para insertar elementos en el
struct nodoCola *p; rbol
p = new(struct nodoCola);
p->ptr = n; void insertarNodo(Nodo *&arbol,int n,Nodo
p->sgte = NULL; *padre){
if(q.delante==NULL) if(arbol == NULL){
q.delante = p; Nodo *nuevo_nodo =
else crearNodo(n,padre);
(q.atras)->sgte = p; arbol = nuevo_nodo;
q.atras = p; }
} else{
ABB desencola(struct cola &q) int valorRaiz = arbol-
{ >dato;
struct nodoCola *p; if(n < valorRaiz){
p = q.delante;
ABB n = p->ptr; insertarNodo(arbol->izq,n,arbol);
q.delante = (q.delante)->sgte; }
delete(p); else{
return n;
} insertarNodo(arbol->der,n,arbol);
}
}
}

//Funcion para mostrar el arbol completo

void mostrarArbol(Nodo *arbol,int cont){
if(arbol == NULL){
return;
} 4
else{
mostrarArbol(arbol-
>der,cont+1);
for(int i=0;i<cont;i++){
 UNA - PUNO INTELIGENCIA ARTIFICIAL

//Funcion para recorrido en profundidad -

PreOrden
void preOrden(Nodo *arbol){
if(arbol == NULL){
return;
} //Funcion para recorrido en Anchura
else{ void Anchura( Nodo *)
cout<<arbol->dato<<" - "; {
preOrden(arbol->izq); struct cola q;
preOrden(arbol->der); inicializaCola(q);
} cout << "\t";
}

//Funcion para recorrido en profundidad - if(arbol!=NULL)

InOrden {
void inOrden(Nodo *arbol){ encola(q, arbol);
if(arbol == NULL){
return; while(q.delante!=NULL)
} {
else{ arbol = desencola(q);
inOrden(arbol->izq); cout << arbol->dato << " - ";
cout<<arbol->dato<<" - ";
inOrden(arbol->der);
} if(arbol->izq!=NULL)
} encola(q, arbol->izq);
if(arbol->der!=NULL)
//Funcion para recorrido en profundidad - encola(q, arbol->der);
PostOrden }
void postOrden(Nodo *arbol){ }
if(arbol == NULL){ }
return;
}
else{
postOrden(arbol->izq);
postOrden(arbol->der);
cout<<arbol->dato<<" - ";
}
}

5
UNA - PUNO INTELIGENCIA ARTIFICIAL

//Funcion de menu
void menu(){
int dato,opcion,contador=0;
do{
cout<< "******Recorridos de un arbol Binario********** <<endl;
cout<< "*********** ************************ **"<< endl;
cout<<endl;
cout<<"1. Insertar un nuevo nodo"<<endl;
cout<<"2. Mostrar el arbol completo"<<endl;
cout<<"3. Recorrido en Profundidad "<<endl;
cout<<"4. Recorrido en Anchura "<<endl;
cout<<"5. Salir"<<endl;
cout<<"Opcion: ";
cin>>opcion;
switch(opcion){
case 1: cout<<"\n Ingrese el valor del Nodo : ";
cin>>dato;
insertarNodo(arbol,dato,NULL);
cout<<"\n";
break;
case 2: cout<<"\n El arbol completo es :\n\n";
mostrarArbol(arbol,contador);
cout<<"\n";
system("pause");
break;

case 3:
cout<< "****Recorrido en Profundidad*********"<< endl;
cout<<endl;
cout<<"\n Recorrido en PreOrden: ";
preOrden(arbol);
cout<<"\n\n";

cout<<"\n Recorrido en InOrden:";

inOrden(arbol);
cout<<"\n\n";

cout<<"\n Recorrido en PostOrden: ";

postOrden(arbol);
cout<<"\n\n";
cout<<"******************** "<<endl;
system("pause");
break;
case 4: cout<< "******Busqueda en anchura*******:"<< endl;
cout<< endl;
Anchura(arbol);
cout<<"\n\n";
cout<<"*********************** ********"<<endl;
system("pause");
break;
}
system("cls");
} while(opcion != 5);
}

6
UNA - PUNO INTELIGENCIA ARTIFICIAL

Resultados: