UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

(Universidad del Perú, DECANA DE AMÉRICA)

FACULTAD DE INGENIERÍA DE SISTEMAS E INFORMÁTICA

Escuela Académico Profesional de Ingeniería de Sistemas

Ingeniería de
Software

TAREA LABORATORIO -ED

Alumno:

Ramírez Osorio, Miguel Antony 17200104

Curso:

Estructura de Datos I

Profesor:

López Villanueva Timoteo Andrés

2019
Ejercicios:

1) Explicar por qué cada una de las siguientes estructuras no es un árbol binario:

(a) (b) (c)

Para el caso (a) no puede ser considerado árbol binario debido a que su grado es 3
(debido al subárbol B que posee 3 nodos hijos).
Para el caso (b) no puede ser considerado árbol binario puesto que en el subárbol C
los nodos D y E apuntan a un mismo nodo hijo, generando un grafo.
Para el caso (c) no pude ni siquiera ser considerado árbol debido a que este es un
grafo.

2) Considérese el árbol siguiente:

a) ¿Cuál es su altura?
La altura de un árbol es el numero maximo de niveles, el árbol tiene 4 niveles, su
altura es 4.

b) ¿Está el árbol equilibrado? ¿Por qué?

Es equilibrado debido a que las alturas de los subárboles no superan entre ellos
en más de 1 nivel.

c) Listar todos los nodos hoja.

Los nodos hoja son: W, T, X, V.

d) ¿Cuál es el predecesor inmediato (padre) del nodo U?

El predecesor inmediato del nodo U es: R.

e) Listar los hijos del nodo R.

Los hijos del nodo R (sucesores directos) son: U, V.

f) Listar los sucesores del nodo R.

Los sucesores del nodo R son: U, V, X.
3) Para cada una de las siguientes listas de letras,
 dibujar el árbol binario de búsqueda que se construye cuando las letras
se insertan en el orden dado,
 realizar recorridos enorden, preorden y postorden del árbol y mostrar la
secuencia de letras que resultan en cada caso.

i. M, Y, T, E, R

M Enorden: E, M, R, T, Y

Preorden: M, E, Y, T, R
E Y
Postorden: E, R, T, Y, M

ii. T, Y, M, E, R

Enorden: E, M, R, T, Y
T
Preorden: T, M, E, R, Y
M Y
Postorden: E, R, M, Y, T

E R

iii. R, E, M, Y, T

R Enorden: E, M, R, T, Y

Preorden: R, E, M, Y, T
E Y
Postorden: M, E, T, Y, R
M T
 iv. C, O, R, N, F, L, A, K, E, S

V Enorden: A, C, E, F, K, L, N, O, R, S
C
Preorden: C, A, O, N, F, E, L, K, R, S
A O Postorden: A, E, K, L, F, N, S, R, O, C

N R

F S

E L

4) En el árbol del Ejercicio 2, recorrer cada árbol utilizando los órdenes

siguientes: NDI, DNI, DIN.

RECORRIDOS:

o NDI: P, R, V, U, X, Q, T, S, W

o DNI: V, R, X, U, P, T, Q, S, W

o DIN: V, X, U, R, T, W, S, Q, P
5) Dibujar los árboles binarios que representan las siguientes expresiones:
a. (A+B) / (C-D)

+ -

A B C D

b. A+B+C/D

A +

B +

C /

c. A- (B-(C-D) / (E+F))

A /

- +

B - E F

C D
 d. (A+B) * ((C+D) / (E+F))

+ /

A B + +

C D E F

e. (A-B) / ((C*D)-(E/F))

- -

A B *

C D E F
 6) El recorrido preorden de un cierto árbol binario produce ADFGHKLPQRWZ y el
recorrido enorden produce GFHKDLAWRQPZ. Dibujar el árbol binario.

Preorden: N, I, D Enorden: I, N, D
ADFGHKLPQRWZ GFHKDL -- A -- WRQPZ.

A es el nodo raíz. GFHKDL Están en el subárbol izquierdo

Z es el nodo más a la derecha WRQPZ Están en el subárbol derecho

Ges el nodo más a la izquierda

ADFG  Están en la parte izquierda GF---HK—D---L----A

HKSon descendientes de F
K Es hijo der. de H (si fuera izquierdo
Iría antes que H
L Es hijo derecho de D(único lugar
disponible)
A
A
D
D
F
F L

G
G H

WRQPZ(Enorden): I, N, D
PQRWZ(Preorden): N, I, D

(Por preorden)
Pnodo principal del subárbol izquierdo A
(Por enorden):
WRQ---P---Z
WRQvan a la izquierda de P D P
(Por preorden):
Q es padre de W y R
(Por enorden): F L Q Z
W va a la izquierda
R es padre de W (no puede ser
hermano debido a que aparecería G H R
antes la Q)
Z hijo derecho de P
K W
7) Escribir un método recursivo que cuente las hojas de un árbol binario :

public int contar_hojas (NodoBinario<T> subarbol) {

if(subarbol==null)
return 0;

else if (subarbol.izq==null && subarbol.der==null)

return 1;

else
return contar_hojas (subarbol.izq) + contar_hojas (subarbol.der);
}

8) Escribir un método que determine el número de nodos que se encuentran en el nivel

n de un árbol binario.

int cantNodoNivel (int nivel) {

return cantNodoNivel (this.subarbol, nivel);
}

public int cantNodoNivel (NodoBinario<T> subarbol, int nivel) {

if (subarbol != null) {

if (nivel == 0)
return cantNodoNivelIzq +cantNodoNivelDer;

int cantNodoIzq = cantNodoNivel (subarbol.izq, n-1);

int cantNodoDer = cantNodoNivel (subarbol.der, n-1);
}
}

9) Escribir un método que tome un árbol como entrada y devuelva el numero de hijos del
árbol.

public int hijosArbol (NodoArbol nodo) {

class NodoArbol {
int acum=0, tempo; int dato;
int nrohijos;
if (nodo.nrohijos ==0) { NodoArbol hijos[ ];
return 1;
} };
else {
for (int i=0; i<nodo.nrohijos++; i++){
acum += hijosArbol (nodo.nrohijos[i]);
}
return acum;
}
}
10) Escribir un método booleano al que se le pase una referencia a un árbol binario y
devuelva verdadero(true) si el árbol es completo falso (false) en caso contrario.

11) Se dispone de un árbol binario de elementos tipo entero. Escribir métodos que
calculen:

a. La suma de sus elementos.

int suma_nodos (NodoBinario<T> subarbol) {

if (subarbol == null)
return 0;

else
return subarbol.dato +suma_nodos (subarbol.izq) +
suma_nodos(subarbol.der);

b. La suma de los elementos que son múltiplos de 3.

private int suma_multitres (NodoBinario subarbol)

{
if (subarbol == null)
return;

if (subarbol.dato mod 3 != 0)
return 0 + suma_multitres (subarbol.izq) +
suma_multitres (subarbol.der);

else
return subarbol.dato +suma_multitres (subarbol.izq) +
suma_multitres(subarbol.der);

}
 12) Diseñar un método iterativo que encuentre el número de nodos hoja en un árbol
binario.

public void contar_hojas (NodoBinario<T> raiz) {

stack<T> pila1, pila2;

NodoBinario<T> aux=raiz;

Int cont=0;

do{ //método número de datos en la pila2

if(!pila2.empty() &&
!pila1.empty() && aux==null) public int numeroDatos () {
{ int cont=0;
return 1; Nodo aux=inicio;
} While (aux != null)
{
if(aux != null ){ System.out.println(aux.valor +
pila1.apilar(aux); “ ,”);
aux=aux.izq; aux=aux.sig;
} cont++;
}
else if (!pila1.empty()){ return cont;
}
aux=pila1.top ();
pila1.desapilar ();
aux=aux.der;

}
else if (aux.der==null &&
aux.izq==null){
pila2.apilar(aux);
}

} while (!pila.empty() | | aux != null);

System.out.println(pila2.numeroDatos());
}
13) En un árbol de búsqueda cuyo campo clave es de tipo entero, escribir un método que
devuelva el numero de nodos cuya clave se encuentra en el rango [x1, x2].

private int nodos_rango (NodoBinario subarbol)

{
int min, max;

if (subarbol == null)
return;

if (subarbol.dato >=min && subarbol.dato =< max)

return 1 + nodos_rango (subarbol.izq) + nodos_rango (subarbol.der);

else
return 0 + nodos_rango (subarbol.izq) + nodos_rango (subarbol.der);

14) Diseñar un método que visite los nodos del árbol por niveles; primero el nivel 0,
después los nodos del nivel 1, y del nivel 2 y así hasta el ultimo nivel.

void RecorrerPorNivel (NodoBinario<T> subarbol){

Nodo Cola q;
q.iniciarCola();
cout<< “\t”;

if (subarbol != null) {
q.encolar( subarbol);

while (q.sig != null){

subarbol= q.desencolar( );
System.out.println(subarbol.dato +” ”);

if (subarbol.izq ==null) {
q.encolar(subarbol.izq);
}

if (subarbol.der ==null) {
q.encolar (subarbol.der);
}
}