Ejercicios Resueltos Árboles - Estructuras de Datos

SOLUCIONES MODULO 09
1. Elabore un algoritmo que cree una copia de una lista generalizada.
Solución:
1. Lg copiaLg()
2. Lg c = new Lg()
3. c.primero = copia(primerNodo())
4. return c
5. Fin(copiaLg)
1. nodoLg copia(nodoLg p)
2. nodoLg x
3. x = null
4. if (p != null) then
5. x = new nodoLg(null)
6. if (p.retornaSw() == 1) then
7. x.asignaSw(1)
8. x.asignaDato(copia((nodoLg)p.retornaDato()))
9. else
10. x.asignaDato(p.retornaDato())
11. end(if)
12. x.asignaLiga(copia(p.retornaLiga()))
13. end(if)
14. return x
15. Fin(copia)
2. Elabore un algoritmo que determine si dos listas generalizadas son iguales.
Solución:
1. boolean iguales(nodoLg L1, nodoLg L2)

2. boolean b
3. if ((L1 == null) and (L2 == null)) return true
4. if ((L1 == null) or (L2 == null)) return false
5. if (L1.retornaSw() != L2.retornaSw()) return false
6. if (L1.retornaSw() == 1) then
7. return iguales((nodoLg)L1.retornaDato(), (nodoLg)L2.retornaDato())
8. else
9. if (L1.retornaDato() == L2.retornaDato())
10. b = true
11. else
12. b = false
13. end(if)
14. end(if)
15. if (b) return iguales(L1.retornaLiga(), L2.retornaLiga())
16. return b
17. Fin(iguales)
3. Elabore un algoritmo que evalúe un polinomio representado como lista generalizada.
Solución:
1. float evaluaPolinomio(nodoPoli x)
2. float res, vv
3. nodoPoliMuchasVariables p
4. res = 0
5. vv = x.retornaCoef().retornaValor()
6. p = x.retornaLiga()
7. while (p != null) do
9. res = res + p.retornaCoef()*vv^p.retornaExpo()
10. else
11. res = res +
evaluaPolinomio(p.retornaCoef())*vv^p.retornaExpo()
12. end(if)
13. p = p.retornaLiga()
14. end(while)
15. return res
16. Fin(evaluaPolinomio)
4. Escriba un algoritmo recursivo que construya una lista generalizada dada la

representación de paréntesis izquierdos, átomos, comas y paréntesis derechos.
Solución:
1. void consLgRec(String s)
2. nn = s.length()
3. j=1
4. primero = construyeLgRecursivo(s)
5. asignaUltimo()
6. Fin(consLgRec)
1. nodoLg construyeLgRecursivo(String s)
2. if (j <= nn) then
3. nodoLg x = new nodoLg(null)
4. if (s.charAt(j) == '(') then
5. x.asignaSw(1)
6. j=j+1
7. x.asignaDato(construyeLgRecursivo(s))
8. else
9. x.asignaDato(s.charAt(j))
10. j=j+1
11. end(if)
12. if (s.charAt(j) == ',') then
13. j=j+1
14. x.asignaLiga(construyeLgRecursivo(s))
15. else
16. j=j+1
17. end(if)
18. return x
19. end(if)
20. return null
21. Fin(construyeLgRecursivo)
5. Elabore un algoritmo que imprima una lista generalizada como una hilera de átomos,
paréntesis izquierdos y paréntesis derechos dada la representación como lista ligada.
Solución:
1. void escribeLg(nodoLg p)
2. write('(')
3. while !finDeRecorrido(p) do
5. write(p.retornaDato())
6. else
7. escribeLg(p.retornaDato())
8. end(if)
9. if (p.retornaLiga() != null) then
10. write(',')
11. end(if)
13. end(while)
14. write(')')
15. Fin(escribeLg)
6. Elabore un algoritmo que reverse una lista generalizada y todas sus sublistas.
Solución:
1. nodoLg reversaLista(nodoLg t)
2. nodoLg p, q, r, s
3. p=t
4. q = null
5. while !finDeRecorrido(p) do
6. r=q
7. q=p
9. q.asignaLiga(r)
10. if (q.retornaSw() == 1) then
11. s = q.retornaDato()
12. q.asignaDato(reversaLista(s))
13. end(if)
14. end(while)
15. primero = q
16. return primero
17. Fin(reversaLista
1. Elabore algoritmo que construya la representación como lista generalizada de un árbol

con base en una hilera de abre paréntesis, átomos, comas y cierre paréntesis.
Solución:
1. void construyeArbol(String s)
2. int n, i
3. nodoLg primero, ultimo, x
4. stack pila
5. primero = new nodoLg(null)
6. ultimo = primero
7. primero.asignaDato(s[2])
8. n = s.longitud()
9. if (n == 3) then
10. return
11. end(if)
12. i=4
13. while (i <= n – 2) do
15. ultimo.asignaLiga(x)
16. ultimo = x
17. if (s[i+1] == '(') then
18. ultimo.asignaSw(1)
19. pila.apilar(ultimo)
20. x = new nodoLg(s[i])
21. ultimo.asignaDato(x)
22. ultimo = x
23. i=i+2
24. else
25. ultimo.asignaDato(s[i])
26. if (s[i+1] == “)”) then
27. i=i+1
28. while (i < n and s[i] ==”)” and !pila.esVacia()) do
29. ultimo = pila.desapilar()
30. i=i+1
31. end(while)
32. if (s[i] == “,”) then
33. i=i+1
34. end(if)
35. else
36. i=i+2
37. end(if)
38. end(if)
39. end(while)
40. Fin(construyeArbol)
2. Elabore algoritmo que determine y retorne el grado de un dato entrado como parámetro
en un árbol representado como lista generalizada.
Solución:
1. int gradoDeUnDato(String d)
2. int n = 0
3. nodoLg p, q
4. Stack pila = new Stack()
5. p = primerNodo()
6. if ((Character)p.retornaDato() == d.charAt(0)) then
9. n=n+1
11. end(while)
12. return n
13. end(if)
18. return 0
19. end(if)
21. else
22. q = (nodoLg)p.retornaDato();
23. if ((Character)q.retornaDato() == d.charAt(0)) then
24. p = q.retornaLiga()
26. n=n+1
28. end(while)
29. return n
30. else
31. pila.apilar(p.retornaLiga())
33. end(if)
34. end(if)
35. while (p == null and !pila.esVacia()) do
36. p = (nodoLg)pila.desapilar();
37. end(while)
38. end(while)
39. write("Dato no está en el árbol")
40. return 0
41. Fin(gradoDeUnDato)
3. Elabore un algoritmo para determinar y retornar el padre de un registro en un árbol

representado como lista generalizada.
Solución:
1. void padreDeUnDato(String d)
2. int n = 0
3. char c
4. nodoLg p, q
6. p = primerNodo()
8. write("El dato es la raiz, por tanto no tiene padre")
9. return
10. end(if)
11. pila.apilar(p.retornaDato())
16. write("El padre de ", d, " es ", pila.desapilar())
17. return
18. end(if)
20. else
21. q = (nodoLg)p.retornaDato()
23. write("El padre de ", d, " es ", pila.desapilar())
24. return
25. else
27. pila.apilar(q.retornaDato())
29. end(if)
30. end(if)
32. c = (Character)pila.desapilar()
33. p = (nodoLg)pila.desapilar()
34. end(while)
35. end(while)
37. Fin(padreDeUnDato)
4. Elabore algoritmo que determine y retorne los ancestros de un dato entrado como
parámetro en un árbol representado como lista generalizada.
Solución:
1. void ancestrosDeUnDato(String d)
2. int n = 0
3. char c
4. nodoLg p, q
6. p = primerNodo()
8. write("El dato es la raiz, por tanto no tiene ancestros")
9. return
10. end(if)
11. pila.apilar(p.retornaDato())
16. write("Los ancestros de ", d, " son ")
17. while (!pila.esVacia()) do
19. write(c, " ")
20. if (!pila.esVacia()) then
22. end(if)
23. end(while)
24. return
25. end(if)
27. else
30. write("Los ancestros de ", d, " son ")
33. write(c, " ")
36. end(if)
37. end(while)
38. return
39. else
41. pila.apilar(q.retornaDato())
43. end(if)
44. end(if)
48. end(while)
49. end(while)
51. Fin(ancestrosDeUnDato)
5. Elabore un algoritmo que determine y retorne la altura de un árbol representado como

lista generalizada
Solución:
1. int altura(nodoLg L)
2. nodoLg p
3. int g, h
4. h=1
5. if (L == null) then
6. return 0
7. end(if)
8. if (L.retornaLiga() == null) then
9. return 1
10. end(if)
11. p=L
14. g = altura((nodoLg)p.retornaDato())
15. if (g > h) then
16. h=g
17. end(if)
18. end(if)
20. end(while)
21. return h + 1
22. Fin(altura)
6. Elabore un algoritmo que escriba la hilera de abre paréntesis, átomos, comas y cierre
paréntesis de un árbol representado como lista generalizada.
Solución:
1. void implg(nodoLg L, int band)

2. nodoLg p, primero, q
4. if (L == null) then
5. write("LISTA VACIA")
6. return
7. end(if)
8. primero = null
9. if (band == 0) then
10. write("(", L.retornaDato())
11. if (L.retornaLiga() == null) then
12. write(")")
13. return
14. end(if)
15. write("(")
16. primero = L
17. end(if)
18. p = L.retornaLiga()
22. else
24. write(q.retornaDato(), “(“)
25. implg((nodoLg)p.retornaDato(),1)
26. end(if)
27. if (p.retornaLiga() != null) then
28. write(",")
29. end(if)
31. end(while)
32. write(")")
33. if (primero == L) then
34. write(")")
35. end(if)
36. Fin(impLg)
7. Elabore un algoritmo que imprima, por niveles, el recorrido sobre un árbol representado
como lista generalizada.
Solución:
1. void muestraPorNiveles()
2. colas cola
3. nodoLg p, q
4. cola = new colas()
5. p = primerNodo()
6. if (p == null) return
9. write((Character)p.retornaDato(), ", ")
10. else
12. write((Character)q.retornaDato(), ", ")
13. cola.encolar(q.retornaLiga())
14. end(if)
16. while (p == null and !cola.esVacia()) do
17. p = (nodoLg)cola.desencolar()
18. end(while)
19. end(while)
20. Fin(muestraPorNiveles)
1. Escriba un algoritmo para determinar el número de hojas de un árbol binario

representado como lista ligada.
Solución:
1. int hojas(nodoDoble r)
2. int hh
3. hh = 0
4. if (r != null) then
5. if (r.retornaLi() == null and r.retornaLd() == null) then
6. hh = hh + 1
7. else
8. hh = hh + hojas(r.retornaLi()) + hojas(r.retornaLd())
9. end(if)
10. end(if)
11. return hh
12. fin(hojas)
2. Escriba un algoritmo para determinar el grado de un árbol binario representado como

lista ligada.
Solución:
1. int grado(nodoDoble r)
2. int g
3. g=0
5. if (r.retornaLi() != null and r.retornaLd() != null) then
6. g=2
7. else
8. if (r.retornaLi() != null or r.retornaLd() != null) then
9. g=1
10. end(if)
11. end(if)
12. g = mayor(g, grado(r.retornaLi()))
13. g = mayor(g, grado(r.retornaLd()))
14. end(if)
15. return g
16. end(if)
3. Escriba un algoritmo para determinar la altura de un árbol binario representado como

lista ligada.
Solución:
1. int altura(nodoDoble r)
2. int altizq, altder
3. if (r == null) then
4. return 0
5. end(if)
6. altizq = 0
7. altder = 0
8. if (r.retornaLi() != null) then
9. altizq = altura(r.retornaLi())
10. end(if)
11. if (r.retornaLd() != null) then
12. altder = altura(r.retornaLd())
13. end(if)
14. return mayor(altizq, altder) + 1
15. fin(altura)
4. Escriba un algoritmo para determinar el padre de un registro en un árbol binario

Solución:
1. int padre(nodoDoble r, int dato)

2. int d, pad
3. nodoDoble p
4. pad = 0
5. if (r != null)
6. if (r.retornaLi() != null) then
7. p = r.retornaLi()
8. d = (Integer)p.retornaDato()
9. if (d == dato) then
10. pad = (Integer)r.retornaDato()
11. end(if)
12. end(if)
13. if (pad == 0) then
14. if (r.retornaLd() != null) then
15. p = r.retornaLd()
16. d = (Integer)p.retornaDato()
17. if (d == dato) then
18. pad = (Integer)r.retornaDato()
19. end(if)
20. end(if)
21. end(if)
23. pad = padre(r.retornaLi(), dato)
25. pad = padre(r.retornaLd(), dato)
26. end(if)
27. return pad
28. Fin(padre)
5. Escriba un algoritmo para determinar los ancestros de un registro en un árbol binario
Solución:
1. void ancestros(int dato)

2. int p
3. Stack pila
4. pila = new Stack()
5. p = padre(raiz, dato)
6. while (p != 0) do
7. pila.apilar(p)
8. p = padre(raiz, p)
9. end(while)
11. p = (Integer)pila.desapilar()
12. write(p)
13. end(while)
14. Fin(ancestros)
6. Elabore un algoritmo que imprima por niveles el recorrido sobre un árbol binario
Solución:
1. void recorrePorNiveles()
2. colas cola
3. nodoDoble p
5. p = raiz
6. cola.encolar(p)
7. while (!cola.esVacia()) do
8. p = (nodoDoble)cola.desencolar()
10. if (p.retornaLi() != null) cola.encolar(p.retornaLi())
11. if (p.retornaLd() != null) cola.encolar(p.retornaLd())
12. end(while)
13. Fin(recorrePorNiveles)
7. Escriba un algoritmo que construya la representación como árbol binario en lista ligada
de un árbol n-ario, representado como lista generalizada.
Solución:
1. void convierteLgABinario(arbolLg a)
2. nodoLg p, q
3. nodoDoble x, ultimo
4. Stack pila
6. p = a.primerNodo()
7. x = new nodoDoble(p.retornaDato())
8. raiz = x
9. ultimo = x
14. else
16. x = new nodoDoble(q.retornaDato())
17. pila.apilar(x)
18. pila.apilar(q.retornaLiga())
19. end(if)
20. ultimo.asignaLi(x)
21. ultimo = x
26. else
28. x = new nodoDoble(q.retornaDato())
29. pila.apilar(x)
30. pila.apilar(q.retornaLiga())
31. end(if)
32. ultimo.asignaLd(x)
33. ultimo = x
35. end(while)
38. ultimo = (nodoDoble)pila.desapilar()
39. end(if)
40. end(while)
45. Fin(convierteLgABinario)
8. Elabore un algoritmo para construir un árbol binario al cual se le dieron los recorridos
PREORDEN e INORDEN.
Solución:
1. void construyeConRecorridos(bector in, bector pre)

2. raiz = reconstruye(in, pre)
3. Fin(construyeConRecorrido)
1. nodoDoble reconstruye(bector in, bector pre)

2. nodoDoble x
3. int i, j, k
4. bector ain, apre
4. if (in.retornaDatoEn(0) == 0) return null
5. x = new nodoDoble(pre.retornaDatoEn(1))
6. k=1
7. while (pre.retornaDatoEn(1) != in.retornaDatoEn(k))
8. k=k+1
9. end(while)
10. apre = pre.copia(2, k)
11. ain = in.copia(1, k – 1)
12. x.asignaLi(reconstruye(ain, apre))
13. apre = pre.copia(k+1, in.retornaDatoEn(0))
14. ain = in.copia(k+1, in.retornaDatoEn(0))
15. x.asignaLd(reconstruye(ain, apre))
16. return x
17. Fin(reconstruye)
9. Elabore algoritmo para construir la representación como lista ligada de un árbol binario
completo dada su representación en vector.
Solución:
1. nodoDoble construyeBinarioComoListaLigada(bector vec, int i)

2. nodoDoble x = null
3. if (i <= vec.retornaDatoEn(0)) then
4. x = new nodoDoble(vec.retornaDatoEn(i))
5. x.asignaLi(construyeBinarioComoListaLigada(vec, 2*i))
6. x.asignaLd(construyeBinarioComoListaLigada(vec, 2*i+1))
7. end(if)
8. return x
9. Fin(construyeBinarioComoListaLigada)
10. Se dice que un árbol binario es zurdo si: está vacío, o es una hoja, o sus hijos
izquierdo y derecho son ambos zurdos, y más de la mitad de sus descendientes están en
el hijo izquierdo. Elabore un algoritmo que determine si un árbol binario representado
como lista ligada es zurdo o no. Su algoritmo debe retornar verdadero si es zurdo falso de
lo contrario.
Solución:
1. parejaZurda esZurdo(nodoDoble r)
2. parejaZurda pi, pd, p
3. int n, ni, nd
4. boolean b, bi, bd
5. p = new parejaZurda(true, 0);
7. if (r.retornaLi() == null and r.retornaLd() == null) then
8. p = new parejaZurda(true, 1)
9. else
10. pi = esZurdo(r.retornaLi())
11. pd = esZurdo(r.retornaLd())
12. bi = pi.retornaP1()
13. bd = pd.retornaP1()
14. ni = pi.retornaP2()
15. nd = pd.retornaP2()
16. n = ni + nd + 1
17. b = bi and bd and (ni > nd)
18. p = new parejaZurda(b, n)
19. end(if)
20. end(if)
21. return p
22. end(esZurdo)
1. Elabore algoritmo para determinar y retornar el número de hojas de un árbol binario

representado como lista ligada enhebrada.
Solución:
1. int hojas(nodoDobleEnhebrado r)
2. int hh
3. hh = 0
4. if (r != raiz) then
5. if (r.retornaBi() == 0 and (r.retornaBd() == 0)) then
6. hh = hh + 1
8. else
9. if (r.retornaBi() == 1) then
10. hh = hh + hojas(r.retornaLi())
11. end(if)
12. if (r.retornaBd() == 1) then
13. hh = hh + hojas(r.retornaLd())
14. end(if)
15. end(if)
16. end(if)
17. return hh
18. Fin(hojas)
1. int hojasEnhebrado(nodoDobleEnhebrado r)
2. nodoDobleEnhebrado p
3. int hh = 0
4. p = siguiente(r)
5. while (p != r) do
6. if (p.retornaBi() == 0 and (p.retornaBd() == 0)) then
7. hh = hh + 1
8. end(if)
9. p = siguiente(p)
10. end(while)
11. return hh
12. end(hojasEnhebrado)
2. Elabore algoritmo para determinar y retornar el grado de un árbol binario representado

como lista ligada enhebrada.
Solución:
1. int grado(nodoDobleEnhebrado r)
2. int g
3. g=0
5. if (r.retornaBi() == 1 and r.retornaBd() == 1) then
6. g=2
7. else
8. if (r.retornaBi() == 1 or r.retornaBd() == 1) then
9. g=1
10. end(if)
11. end(if)
12. if (g == 2) return g
14. g = grado(r.retornaLi())
15. end(if)
16. if (g == 2) return g
18. g = grado(r.retornaLd())
19. end(if)
20. end(if)
21. return g
22. Fin(grado)
1. int gradoEnhebrado(nodoDobleEnhebrado r)
3. int g = 0
4. p = siguiente(r)
6. if (p.retornaBi() == 1 and (p.retornaBd() == 1)) return 2
7. if (r.retornaBi() == 1 or r.retornaBd() == 1) g = 1
8. p = siguiente(p)
9. end(while)
10. return g
11. Fin(gradoEnhebrado)
3. Elabore algoritmo para determinar y retornar la altura de un árbol binario representado

como lista ligada enhebrada.
Solución:
1. int altura(nodoDobleEnhebrado r)
2. int altizq, altder
3. if (r == raiz) return 0
4. altizq = 0
5. altder = 0
7. altizq = altura(r.retornaLi())
8. end(if)
10. altder = altura(r.retornaLd())
11. end(if)
12. if (altizq > altder) return altizq + 1
13. return altder + 1
14. Fin(altura)
4. Elabore un algoritmo para determinar el padre de un registro en un árbol binario

representado como lista ligada enhebrado en inorden.
Solución:
1. int padre(int dato)

2. nodoDobleEnhebrado p, q
3. p = raiz.retornaLi()
4. if (p == raiz) then
5. write("Arbol vacio")
6. return 0
7. end(if)
8. if ((Integer)p.retornaDato() == dato) then
9. write("El dato es la raiz, no tiene padre")
10. return 0
11. end(if)
12. p = siguiente(raiz)
13. while (p != raiz) do
14. if ((Integer)p.retornaBi() == 1) then
15. q = p.retornaLi()
16. if ((Integer)q.retornaDato() == dato) return
(Integer)p.retornaDato()
17. end(if)
18. if (p.retornaBd() == 1) then
19. q = p.retornaLd()
20. if ((Integer)q.retornaDato() == dato) return
(Integer)p.retornaDato()
21. end(if)
22. p = siguiente(p)
23. end(while)
25. return 0
26. Fin(padre)
5. Elabore algoritmo para enhebrar en inorden un árbol representado como lista ligada no
enhebrado.
Solución:
1. int construyeVectorDirecciones(nodoDobleEnhebrado r, nodoDobleEnhebrado

V[])
3. int i = 0
4. Stack pila
6. p=r
8. pila.apilar(p)
9. p = p.retornaLi()
10. end(while)
12. p = (nodoDobleEnhebrado)pila.desapilar()
13. i=i+1
14. V[i] = p
15. p = p.retornaLd()
17. pila.apilar(p)
18. p = p.retornaLi()
19. end(while)
20. end(while)
21. return i
22. Fin(construyeVectorDirecciones)
1. void enhebraElArbol(nodoDobleEnhebrado V[], int n)

2. int k
3. colas cola
4. nodoDobleEnhebrado p, cabeza
6. cabeza = new nodoDobleEnhebrado(null)
7. V[0] = cabeza
8. V[n+1] = cabeza
9. cabeza.asignaLi(raiz)
10. p = raiz
11. cola.encolar(p)
12. while (!cola.esVacia()) do
13. p = (nodoDobleEnhebrado)cola.desencolar()
14. if (p.retornaLi() == null) then
15. k=1
16. while (V[k] != p) do
17. k = k +1
18. p.asignaLi(V[k – 1])
19. p.asignaBi(0)
20. end(if)
21. if (p.retornaLd() == null) then
22. k=1
23. while (V[k] != p) do
24. k = k +1
25. end(while)
26. p.asignaLd(V[k+1])
27. p.asignaBd(0)
28. end(if)
29. if (p.retornaLi() != null and p.retornaBi() == 1)
cola.encolar(p.retornaLi())
30. if (p.retornaLd() != null and p.retornaBd() == 1)
cola.encolar(p.retornaLd())
31. end(while)
32. raiz = cabeza
33. Fin(enhebraElArbol)
6. Elabore algoritmo para recorrer en preorden un árbol binario representado como lista
ligada enhebrada en inorden.
Solución:
1. void preorden(nodoDobleEnhebrado r)
3. write(r.retornaDato())
4. if (r.retornaBi() == 1) preorden(r.retornaLi())
5. if (r.retornaBd() == 1) preorden(r.retornaLd())
6. end(if)
7. Fin(preorden)
7. Elabore algoritmo para recorrer en posorden un árbol binario representado como lista
ligada enhebrada en inorden.
Solución:
1. void posorden(nodoDobleEnhebrado r)
3. if (r.retornaBi() == 1) posorden(r.retornaLi())
4. if (r.retornaBd() == 1) posorden(r.retornaLd())
6. end(if)
7. Fin(posorden)
1. Elabore algoritmo para hacer doble rotación a la izquierda.
Solución:
1. nodoDobleAVL dobleRotacionIzquierda(nodoDobleAVL p, nodoDobleAVL q)
2. nodoDobleAVL r
3. r = q.retornaLi()
4. q.asignaLi(r.retornaLd())
5. r.asignaLd(q)
6. p.asignaLd(r.retornaLi())
7. r.asignaLi(p)
8. casos de (r.retornaFb())
9. 0: p.asignaFb(0)
10. q.asignaFb(0)
11. break
12. 1: p.asignaFb(0)
13. q.asignaFb(-1)
14. break
15. -1: p.asignaFb(1)
16. q.asignaFb(0)
17. fin(casos)
18. r.asignaFb(0)
19. return r
20. Fin(dobleRotacionIzquierda)
2. Elabore algoritmo que determine si un árbol binario cualquiera está balanceado por
altura o no. Su algoritmo debe retornar verdadero si está balanceado por altura falso de lo
contrario.
Solución:
1. boolean esBalanceado(nodoDoble r)
2. int hi, hd
3. boolean b = true
5. hi = altura(r.retornaLi())
6. hd = altura(r.retornaLd())
7. if (abs(hi – hd) > 1) b = false
8. if (b) b = esBalanceado(r.retornaLi())
9. if (b) b = esBalanceado(r.retornaLd())
10. end(if)
11. return b
12. Fin(esBalanceado)
3. Modifique el algoritmo dobleRotacionALaDerecha de tal manera que no utilice

instrucciones de decisión para recalcular los nuevos factores de balance de los nodos p, q
y r. Es decir, las instrucciones 7 a 16 las debe reemplazar por instrucciones de
asignación.
Solución:
1. nodoDobleAVL dobleRotacionDerechaSimplificado(nodoDobleAVL p,
nodoDobleAVL q)
2. nodoDobleAVL r
3. r = q.retornaLd()
4. q.asignaLd(r.retornaLi())
5. r.asignaLi(q)
6. p.asignaLi(r.retornaLd())
7. r.asignaLd(p)
8. p.asignaFb((q.retornaFb() – r.retornaFb())/2)
9. q.asignaFb((p.retornaFb() – r.retornaFb())%2)
// p.asignaFb((p.retornaFb() + r.retornaFb())%3 + q.retornaFb())
// q.asignaFb((p.retornaFb() + r.retornaFb())%3)
10. r.asignaFb(0)
11. return r
12. Fin(dobleRotacionDerechaSimplificado)
Algoritmo para construir lista generalizada a partir de una hilera:
1. void conslg(string s)
4. L=x
5. ultimo = x
6. n = longitud(s)
7. for (i = 2; i < n; i++) do
8. casos de s[i]
9. átomo:
11. ultimo.asignaDato(s[i])
12. ”,”:
14. ultimo.asignaLiga(x)
15. ultimo = x
16. ’(‘:
17. pila.apilar(ultimo)
20. ultimo.asignaDato(x)
21. ultimo = x
22. ’)’:
23. ultimo = pila.desapilar()
24. fin(casos)
25. end(for)
26. Fin(conslg)
Algoritmo para determinar número de hojas en lista generalizada:
1. entero hojasLg(nodoLg r)
2. if (r == null) then
3. return 0
4. end(if)
5. if (r.retornaLiga() == null) then
6. return 1
7. end(if)
8. hojas = 0
9. p = r.retornaLiga()
12. hojas = hojas + 1
13. else
14. hojas = hojas + hojasLg((nodoLg)p.retornaDato())
15. end(if)
17. end(while)
18. return hojas
19. Fin(hojasLg)
Algoritmo para determinar el grado de un arbol en lista generalizada;
entero gradoLg(nodoLg r)
2. if (r == null or r.retornaLiga() == null) then
3. return 0
4. end(if)
5. grado = 0
6. cuenta = 0
7. p = r.retornaLiga()
9. cuenta = cuenta + 1
11. g = gradoLg((nodoLg)p.retornaDato()
12. if (g > grado) then
13. grado = g
14. end(if)
15. end(if)
17. end(while)
18. if (cuenta > grado) then
19. grado = cuenta
20. end(if)
21. return grado
22. Fin(gradoLg)
Recorridos árbol binario:
1. void inorden(nodoDoble r)
3. inorden(r.retornaLi())
5. inorden(r.retornaLd())
6. end(if)
7. Fin(inorden)
1. void posorden(nodoDoble r)
3. posorden(r.retornaLi())
4. posorden(r.retornaLd())
6. end(if)
7. Fin(posorden)
1. void preorden(nodoDoble r)
4. preorden(r.retornaLi())
5. preorden(r.retornaLd())
6. end(if)
7. Fin(preorden)
Algoritmo heapsort:
El algoritmo que efectúa la tarea de convertir un árbol binario en un heap es:
1. void ajuste(int i, int n)

2. int d, j
3. d = V[i]
4. j=2*i
5. while (j <= n) do
6. if (j < n and V[j] < V[j+1]) then
7. j=j+1
8. end(if)
9. if (d >= V[j]) then
10. V[j / 2] = d
11. return
12. end(if)
13. V[j / 2] = V[j]
14. j=2*j
15. end(while)
16. V[j / 2] = d
17. Fin(ajuste)
1. void ordenaAscendenteHeapSort()
2. int i
3. for (i = n / 2; i > 0; i --) do
4. ajuste(i, n)
5. end(for)
6. for (i = n – 1; i > 0; i --) do
7. intercambia(i+1, 1)
8. ajuste(1, i)
9. end(for)
10. Fin (ordenaAscendenteHeapSort)
Árboles enhebrados:
1. nodoDoble siguiente(nodoDoble x)
2. siguiente = x.retornaLd()
3. if (x.retornaBd() == 1)
4. while (siguiente.retornaBi() == 1)
5. siguiente = siguiente.retornaLi()
6. end(while)
7. end(if)
8. return siguiente
9. Fin(siguiente)
1. void inorden(nodoDoble r)
2. p = siguiente(r)
5. p = siguiente(p)
6. end(while)
7. Fin(inorden)
1. void dobleRotacionALaDerecha(nodoAVL p, nodoAVL q)

2. r = q.retornaLd()
3. q.asignaLd(r.retornaLi())
4. r.asignaLi(q)
5. p.asignaLi(r.retornaLd()
6. r.asignaLd(p)Ld(r)
7. Casos de r.retornaFb()
8. 0: p.asignaFb(0)
9. q.asignaFb(0)
10. break
11. 1: p.asignaFb(–1)
12. q.asignaFb(0)
13. break
14. –1: p.asignaFb(0)
15. q.asignaFb(1)
16. fin(casos)
17. r.asignaFb(0)
18. q=r
19. Fin(dobleRotacionALaDerecha)
Insertar dato en ABB:
void insertaNodo(dato d)
x = new nodoDoble(d)
if(raiz == null){
raiz = x
return
}
p = raiz
q = null
while (p ¡= null)do
q=p
if(d <p.retornaDato()){
p = p.retornali()
} else {
P = p.retornald()
}
If(d < q.retornaDato()){
q.asignali(x)
}else {
q.asignald(x)
}
Algoritmo para hallar nodo de padre en lista generalizada:
Algoritmo siguiente en binario enhebrado en preorden:
1. nodoDoble siguiente(nodoDoble x)
2. siguiente = x.retornaLd()
3. if(x.retornaBi() == 1 and x.retornaBd() == 1)then
4. siguiente = x.retornaLi()
5. end(if)
6. return siguiente
7. fin(siguiente)
1. Se tiene un árbol binario representado como lista ligada enhebrado en inorden.
Elabore un algoritmo que retorne verdadero si el árbol está balanceado por altura,
falso de lo contrario.
3. Se tiene un árbol n-ario representado como lista generalizada. Elabore un algoritmo
que reciba como parámetros dos datos y que retorne verdadero si dichos datos son
primos. Dos datos son primos si sus padres son hermanos.
4. Se tiene un árbol binario de búsqueda representado como lista ligada. Elabore un
algoritmo que elimine el nodo correspondiente a un dato d entrado como parámetro.
Elabore todo método que invoque.
public static void eliminarEnbinbus(NodoDoble raiz, int dato) {

NodoDoble q = null, r = null;
NodoDoble p = padre(raiz, dato);
if (p == null) {
if (raiz.retornaDato() == dato) {
q = raiz;
p = q;
} else {
System.out.println("El Dato no se encuetra en el arbol");
return;
}
} else {
if (p.retornaDato() > dato) {
q = p.retornaLi();
} else {
q = p.retornaLd();
}
}
r = q.retornaLd();
if (r != null) {
while (r.retornaLi() != null) {
r = r.retornaLi();
}
r.asignaLi(q.retornaLi());
if (p.retornaDato() > dato) {
p.asignaLi(q.retornaLd());
} else {
p.asignaLd(q.retornaLd());
}
} else if (p.retornaDato() > dato) {

p.asignaLi(q.retornaLi());
} else {
p.asignaLd(q.retornaLi());
}
}
5. Construya un algoritmo que determine y retorne la altura de un árbol n-ario
representado como árbol binario en lista ligada.
6. Se tiene un árbol cualquiera (n - ario) representado como lista generalizada. Elabore
un algoritmo que muestre todos los tíos de un dato entrado como parámetro.
7. Se tiene un árbol n-ario representado como árbol binario en lista ligada. Elabore un
algoritmo que determine y muestre el grado del árbol n-ario con base en su
representación como árbol binario. Elabore todo método que invoque.
8. Se tienen dos árboles binarios A y B representados como listas ligadas. Elabore
un algoritmo que retorne el árbol que tenga más nodos con grado dos. Elabore todo
método que invoque.
10. Se tiene un árbol binario representado como lista ligada. Elabore un algoritmo
que retorne verdadero si todas las hojas del árbol están en el mismo nivel, falso de
lo contrario. Elabore todo método que invoque.
11. Se tiene un árbol n-ario representado como lista generalizada. Elabore algoritmo
que muestre (escriba) las hojas del árbol, cada una con su correspondiente nivel.
Elabore todo método que invoque. No use variables globales.
12. Se tiene un árbol binario representado como lista ligada enhebrado en inorden.
Elabore un algoritmo que inserte un nodo z como hijo derecho de un nodo x. Elabore
todo método que invoque.
13. Se tiene un árbol binario representado como lista generalizada. Elabore algoritmo
que muestre el recorrido preorden sobre dicho árbol. Elabore todo método que
invoque.
1. void insertaDatoEnAVL(d)
2. x = new nodoAVL(d) Consigue nuevo registro y lo configura
3. if (r == null) then Si es la primer vez que se llama el

4. r=x procedimiento, el registro conseguido
5. return es la raíz.
6. end(if)
7. p=r Asigna valores iniciales a las variables
8. q = null que se utilizan para buscar el sitio donde
9. pivote = r se insertará nuevo registro y determinar
10. pp= null PIVOTE y su padre.
12. if (p.retornaDato() == d) then Controla que no vayan a
13. return quedar datos repetidos
14. end(if)
15. If (p.retornaFB() != 0) then
16. pivote = p Determina valor de PIVOTE
17. pp = q y de su padre.
18. end(if)
19. q=p
20. if (p.retornaDato() > d) then Actualiza Q
21. p = p.retornaLi() y
22. else avanza con P
24. end(if)
25. end(while)
26. if (q.retornaDato() > d) then
27. q.asignaLi(x) Conecta x como hijo izquierdo
28. else o como hijo derecho de Q
29. q.asignaLd(x)
30. end(if)
31. aux = pivote.retornaFb()
32. if (pivote.retornaDato() > d) then
33. pivote.asignaFb(aux + 1)
34. q = pivote.retornaLi() Recalcula factor de balance
35. else de PIVOTE
36. pivote.asignaFb(aux – 1)
37. q = pivote.retornaLd()
38. end(if)
39. p=q
40. while (p != x) do
41. if (p.retornaDato() > d) then
42. p.asignaFb(+1) Recalcula factores de balance
43. p = p.retornaLi() de todos los registros en la
44. else trayectoria desde PIVOTE hasta
45. p.asignaFb(–1) el registro insertado x
47. end(if)
48. end(while)
49. if (abs(pivote.retornaFb()) < 2) then Si el árbol siguió balanceado
50. return retorna al programa llamante.
51. end(if)
52. if (pivote.retornaFb() == +2) then
53. if (q.retornaFb() = +1) then
54. unaRotacionALaDerecha(pivote, q) Determina qué
55. else tipo de
56. dobleRotacionALaDerecha(pivote, q) rotación que
hay
57. end(if) que efectuar
58. else y llama
59. if (q.retornaFb() == –1) then el
60. unaRotacionALaIzquierda(pivote, q)
procedimiento
61. else
correspondiente
62. dobleRotacionALaIzquierda(pivote, q)
63. end(if)
64. end(if)
65. if (pp == null) then Si el registro desbalanceado
66. r=q era la raíz actualiza la nueva
67. return raíz y regresa.
68. end(if)
69. if (pivote == pp.retornaLi() then
70. pp.asignaLi(q) Pega la nueva raíz del árbol
71. else rebalanceado al registro Q.
72. pp.asignaLd(q)
73. end(if)
74. Fin(insertaDatoEnAVL)
Algotirmo padre retornando nodo en lista ligada.
public static NodoDoble padre(NodoDoble r, int dato) {

int d;
NodoDoble p, pad;
pad = null;
if (r != null) {
if (r.retornaLi() != null) {
p = r.retornaLi();
d = p.retornaDato();
if (d == dato) {
pad = r;
}
}
if (pad == null) {
if (r.retornaLd() != null) {
p = r.retornaLd();
d = p.retornaDato();
if (d == dato) {
pad = r;
}
}
}
if (pad == null) {
pad = padre(r.retornaLi(), dato);
}
if (pad == null) {
pad = padre(r.retornaLd(), dato);
}
}
return pad;
}

Ejercicios Resueltos Árboles - Estructuras de Datos

Cargado por

Copyright:

Formatos disponibles

Ejercicios Resueltos Árboles - Estructuras de Datos

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ejercicios Resueltos Árboles - Estructuras de Datos

Cargado por

Copyright:

Formatos disponibles

SOLUCIONES MODULO 09

1. Elabore un algoritmo que cree una copia de una lista generalizada.

2. Elabore un algoritmo que determine si dos listas generalizadas son iguales.

1. boolean iguales(nodoLg L1, nodoLg L2)

4. Escriba un algoritmo recursivo que construya una lista generalizada dada la

1. Elabore algoritmo que construya la representación como lista generalizada de un árbol

3. Elabore un algoritmo para determinar y retornar el padre de un registro en un árbol

5. Elabore un algoritmo que determine y retorne la altura de un árbol representado como

1. void implg(nodoLg L, int band)

1. Escriba un algoritmo para determinar el número de hojas de un árbol binario

2. Escriba un algoritmo para determinar el grado de un árbol binario representado como

3. Escriba un algoritmo para determinar la altura de un árbol binario representado como

4. Escriba un algoritmo para determinar el padre de un registro en un árbol binario

1. int padre(nodoDoble r, int dato)

1. void ancestros(int dato)

1. void construyeConRecorridos(bector in, bector pre)

1. nodoDoble reconstruye(bector in, bector pre)

1. nodoDoble construyeBinarioComoListaLigada(bector vec, int i)

1. Elabore algoritmo para determinar y retornar el número de hojas de un árbol binario

2. Elabore algoritmo para determinar y retornar el grado de un árbol binario representado

3. Elabore algoritmo para determinar y retornar la altura de un árbol binario representado

4. Elabore un algoritmo para determinar el padre de un registro en un árbol binario

1. int padre(int dato)

1. int construyeVectorDirecciones(nodoDobleEnhebrado r, nodoDobleEnhebrado

1. void enhebraElArbol(nodoDobleEnhebrado V[], int n)

1. Elabore algoritmo para hacer doble rotación a la izquierda.

3. Modifique el algoritmo dobleRotacionALaDerecha de tal manera que no utilice

Algoritmo para construir lista generalizada a partir de una hilera:

Algoritmo para determinar número de hojas en lista generalizada:

Algoritmo para determinar el grado de un arbol en lista generalizada;

Recorridos árbol binario:

El algoritmo que efectúa la tarea de convertir un árbol binario en un heap es:

1. void ajuste(int i, int n)

1. void dobleRotacionALaDerecha(nodoAVL p, nodoAVL q)

Insertar dato en ABB:

public static void eliminarEnbinbus(NodoDoble raiz, int dato) {

} else if (p.retornaDato() > dato) {

3. if (r == null) then Si es la primer vez que se llama el

public static NodoDoble padre(NodoDoble r, int dato) {

También podría gustarte