Ingeniera en Informtica Empresarial - OOP

A (3419A201), Otoo del 2016

Taller: Manejo de listas enlazadas y rboles Binarios

Conceptos a evaluar, "Listas enlazadas Simple y rboles binarios

Crear una lista de nmeros aleatorios. Insertar los nuevos nodos por la cabeza de la lista. Un
vez creada la lista, se han de recorrer los nodos para mostrar los nmero pares.

Se debe crear una lista enlazada de nmeros enteros; para ello se definen la clase Nodo y la
clase Lista. En esta ltima se definen los mtodos insertarCabezaLista() que aade un nodo a
la lista, siempre como nodo cabeza; y el mtodo visualizar() que recorre la lista escribiendo el
campo dato de cada nodo. Desde el mtodo main() se crea un objeto Lista, se llama
iterativamente al mtodo que aade nuevos elementos, y por ltimo se llama a visualizar()
para mostrar los elementos. Para generar nmeros aleatorios se utiliza la clase Random
(paquete java.util).

import java.util.*; public void visualizar() {

public class Nodo { Nodo n;
int dato; n = primero;
Nodo enlace; while (n != null) {
public Nodo(int x){ System.out.println(n.dato%2 != 0 ? "---" :
dato = x; n.dato);
enlace = null; n = n.enlace;
} }
public int getDato() { }
return dato; }
}
public Nodo getEnlace() { class ListaAleatoria {
return enlace; public static void main(String [] a) {
} Random r;
public void setEnlace(Nodo enlace) { int d;
this.enlace = enlace; Lista lista;
} int k;
r = new Random();
} lista = new Lista(); // crea lista vaca
class Lista { k = Math.abs(r.nextInt()% 55);
protected Nodo primero; System.out.println("Nmero de Nodos:"+ k);
public Lista() { for (; k > 0; k-- ) {
primero = null; d = r.nextInt() % 99 ;
} System.out.println("Nmero Generado:"+ d);
lista.insertarCabezaLista(d);
public Lista insertarCabezaLista(int }
entrada) { System.out.println("Elementos de la lista
Nodo nuevo ; generados al azar");
nuevo = new Nodo(entrada); lista.visualizar();
nuevo.enlace = primero; }
primero = nuevo; }
return this;
}

Disear y escribir en Java la funcin mismaEstructura, tal que dados dos rboles binarios diga
si estos tienen o no la misma estructura (misma estructura significa que los rboles son
iguales, excepto los valores de los nodos).
En el ejemplo de la figura:
mismaEstructura(arbol_1, arbol_2) devolvera true
mismaEstructura(arbol_1, arbol_3) devolvera false.

class Nodos { public static void treeInsert(Nodos root, int

int data; newData) {
Nodos small; if (newData<=root.data) {
Nodos large; if (root.small!=null) treeInsert(root.small,
public Nodos(int data) { newData);
this.data = data; else root.small = new Nodos(newData);
small = null; }
large = null; else {
} if (root.large!=null) treeInsert(root.large,
} newData);
else root.large = new Nodos(newData);
class TreeList { }
public static void join(Nodos a, Nodos b) { }
a.large = b;
b.small = a; public static void printTree(Nodos root) {
} if (root==null) return;
printTree(root.small);
public static Nodos append(Nodos a, Nodos b) System.out.print(Integer.toString(root.data) + "
{ ");
// if either is null, return the other printTree(root.large);
if (a==null) return(b); }
if (b==null) return(a);
// find the last node in each using the
.previous pointer public static void printList(Nodos head) {
Nodos aLast = a.small; Nodos current = head;
Nodos bLast = b.small; while (current != null) {
// join the two together to make it System.out.print(Integer.toString(current.data) +
connected and circular " ");
join(aLast, b); current = current.large;
join(bLast, a); if (current == head) break;
return(a); }
} System.out.println();
}
public static Nodos treeToList(Nodos root)
{ public static void main(String[] args) {
// base case: empty tree -> empty list Nodos root = new Nodos(4);
if (root==null) return(null); treeInsert(root, 2);
// Recursively do the subtrees (leap of treeInsert(root, 1);
faith!) treeInsert(root, 3);
Nodos aList = treeToList(root.small); treeInsert(root, 5);
Nodos bList = treeToList(root.large); System.out.println("tree:");
root.small = root; printTree(root); // 1 2 3 4 5
root.large = root; System.out.println();
aList = append(aList, root); System.out.println("list:");
aList = append(aList, bList); Nodos head = treeToList(root);
return(aList); printList(head);
} }
}