Nancy Alejandra sanchez serrato

1. Implemente los siguientes métodos en la clase BST:

a. remove(x): busca el elemento x en el árbol y lo elimina. Retorna verdadero si el elemento se

encontraba en el árbol, y falso en caso contrario.

b. size(): retorna el número de elementos en el árbol.

Public static size(Tx ) {

Return size ;
}

c. height(): retorna la altura del árbol.

public int getAltura(){
int altura=0;
Node cur = root;
while(cur.right!=null&& cur.right!=null&&cur!=null){
if (cur.right==null&&cur.left!=null){
cur=cur.left;
altura++;
}
if(cur.left==null&&cur.right!=null) {
cur=cur.right;
altura++;
}
}

return altura;

d. antecessor(x): retorna el mayor valor en el árbol menor que x, o null si dicho valor no existe.
e. successor(x): retorna el menor valor en el árbol mayor que x, o null si dicho valor no existe.
f. isComplete(): retorna verdadero si el árbol es completo, y falso en caso contrario.
g. equals(tree): retorna verdadero si la estructura y valores en el BST tree son iguales a los del objeto
que hace la invocación.
2. Sea T un árbol binario conteniendo valores Character. Escriba una función que reciba como entrada dos
cadenas correspondientes a los recorridos inorden y postorden de T, y retorne una cadena que contenga su
recorrido en preorden.

public List<T> preorden(){

LinkedList<T> list = new LinkedList<T>();

preorden(list, root);

return list;

private void preorden(List<T> list, Node node) {

if (node == null) return;

list.add(node.data);

preorden(list, node.left);

preorden(list, node.right);

public List<T> inorden(){

LinkedList<T> list = new LinkedList<T>();

inorden(list, root);

return list;

private void inorden(List<T> list, Node node) {

if (node == null) return;

inorden(list, node.left);

list.add(node.data);

inorden(list, node.right);

public List<T> posorden(){

LinkedList<T> list = new LinkedList<T>();

 posorden(list, root);

return list;

private void posorden(List<T> list, Node node) {

if (node == null) return;

posorden(list, node.left);

posorden(list, node.right);

list.add(node.data);

3. a. Cree la clase RandomizedBinaryTree que contenga el método add(x, root), el cual implementa el
siguiente algoritmo de inserción:

 Si el árbol es vacío, se inserta x en la raíz.

 Si el árbol es no vacío, se lanza una moneda. Si el resultado es “cara”, se invoca el método
recursivamente con el subárbol izquierdo de la raíz; en caso contrario, se invoca el método
con el subárbol derecho de la raíz.

Inserte los números naturales de 1 a 1000 en un RandomizedBinaryTree y calcule la altura del árbol
resultante. Repita este experimento 10000 veces. ¿Cuál es la altura promedio de los árboles generados? ¿Qué
puede concluir de dicho promedio?

public class RandomizedBinaryTree <T extends Comparable<T>>{

int altura;

class Node {

T data;

Node left;

Node right;

Node root;
public void add(T x) {

Node node = new Node();

node.data = x;

if (root == null)

root = node;

else {

Node cur =root;

Node ant_cur= cur;

Random gen = new Random();

while(cur!=null){

if (gen.nextInt(2)==0) {

ant_cur=cur;

cur=cur.left;

else {

ant_cur=cur;

cur=cur.right;

if (x.compareTo(ant_cur.data) <= 0) ant_cur.left = node;

else ant_cur.right = node;

public int getAltura() {

altura = 0;
 getAltura(root, 1);

return altura;

private void getAltura(Node reco, int nivel) {

if (reco != null) {

getAltura(reco.left, nivel + 1);

if (nivel > altura) {

altura = nivel;

getAltura(reco.right, nivel + 1);

public static void main(String[] args) {

int suma=0;

List <Integer>alturas= new ArrayList<Integer> ();

BST<Integer> p = new BST<Integer>();

for (int i = 0; i < 1000; i++) {

for (int j = 0; j <1000 ; j++) {

p.add(j);

alturas.add(p.getAltura());

Iterator<Integer> it = alturas.iterator();

while (it.hasNext()){

int x = it.next();

System.out.println("X: " + x);

suma+=x;
 }

System.out.println(suma/alturas.size());

}
4. Para cada permutación P de {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

i. Inserte los elementos de P en un BST en el mismo orden en que aparecen en P.

ii. Calcule la altura del árbol resultante.
private static Comparable[] nextPermutation( final Comparable[] c ) {

// 1. finds the largest k, that c[k] < c[k+1]

int first = getFirst( c );

if ( first == -1 ) return null; // no greater permutation

// 2. find last index toSwap, that c[k] < c[toSwap]

int toSwap = c.length - 1;

while ( c[ first ].compareTo( c[ toSwap ] ) >= 0 )

--toSwap;

// 3. swap elements with indexes first and last

swap( c, first++, toSwap );

// 4. reverse sequence from k+1 to n (inclusive)

toSwap = c.length - 1;

while ( first < toSwap )

swap( c, first++, toSwap-- );

return c;

// finds the largest k, that c[k] < c[k+1]

// if no such k exists (there is not greater permutation), return -1

private static int getFirst( final Comparable[] c ) {

for ( int i = c.length - 2; i >= 0; --i )

if ( c[ i ].compareTo( c[ i + 1 ] ) < 0 )
 return i;

return -1;