// ---------- PREGUNTA1 ------------

// Archivo p1.java

class p1{



public static void main(String []args){



	Nodo raiz = new Nodo( "C", 

				new Nodo("B",null,null), 

				new Nodo("D",

					null, 

					new Nodo("F",null,null)) );

	Nodo raiz2= null;

	Nodo raiz3= new Nodo("C", 

				new Nodo("B",null,null), 

				new Nodo("F",

					new Nodo("E",null,null),

					new Nodo("F",null,null)) );



	System.out.println(esABB(raiz)  + " - " + sucesor(raiz) );	//true - D

	System.out.println(esABB(raiz2) + " - " + sucesor(raiz2));	//true - null

	System.out.println(esABB(raiz3) + " - " + sucesor(raiz3));	//false - E



}



static boolean esABB(Nodo x){

        if(x==null)

                return true;

                

        return  ( x.izq==null 

			? true 

			: ( x.valor.compareTo(x.izq.valor)<=0 ? false : esABB(x.izq) ) 

		     ) 

                && 

                ( x.der==null 

			? true 

			: ( x.valor.compareTo(x.der.valor)>=0 ? false : esABB(x.der) ) 		     );

}



static String sucesor(Nodo x){

	if(x==null || x.der==null)

		return null;

	String s = (String)x.der.valor;

	Nodo y = x.der;

	while(y.izq!=null){

		s = (String)y.izq.valor;

		y=y.izq;

	}

	return s;

}



}











// ---------- PREGUNTA2 ------------

// Archivo p2.java

public class p2{



	static int M=20;	

	static int[] Comparable=new int[M];	

		

	public static void Ordena( int[] A ){

		T1 temp1 = new T1();		//cambiar por T2 para usar Heap

		for(int k=0; k<A.length; k++)

			temp1.agregar(A[k]);

		for(int k=0; k<A.length; k++)

			A[k]=temp1.extraerMenor();

	}	



	static public void main(String[] args){

		int h;

		for( int k=0;k<M; k++){	

			h=(int)Math.floor(100*Math.random() );

			Comparable[k]=h;

		}

		Ordena(Comparable);

		for( int k=0;k<M; k++)

			System.out.println(Comparable[k]);

	}

}































































// Archivo T2.java

public class T2{

	

	private int Max=10000;

	private int[] K;

	private int rmax; 

	

	public T2(){

		K=new int[Max];

		rmax=0;

	}

	

	public int extraerMenor(){

		int temp=K[0];

		int donde=0;

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

			if( temp>K[j] ){

				temp=K[j];

				donde=j;

			}

		}

		K[donde]=K[--rmax];

		return temp;	

	}



	public void agregar(int G){

		if(rmax==Max)

			return;

		K[rmax++]=G;

		return;

	}

}



















































// Archivo T1.java

import java.io.*;



public class T1{

	private int MaxN=10000;

	private int[] Heap;

	private int n;

	public T1(){

		Heap=new int[MaxN];

		n=0;	// Almacena el nmero de elementos

	}

	

	public void agregar(int x){

		Heap[n]=x;

		int m=(int)Math.floor(n/2);

		int j=n;

	    	while( Heap[j]<Heap[m] ){ // intercambiamos con el padre

	        	int t=Heap[j];

	        	Heap[j]=Heap[m];

	        	Heap[m]=t;

	        	j=m;

	        	m=(int)Math.floor(j/2);

	        	if(j==m)

	        		break;

	    	}

	    	n++;

	}

      

	public int extraerMenor(){

		int m=Heap[0];  // La variable m lleva el mnimo

    		Heap[0]=Heap[--n];  // Movemos el ltimo a la raz y achicamos el heap

    		int j=0;

    		int k,t;

    		while(2*j+1<n){ // mientras tenga algn hijo

 			k=2*j+1; // el hijo izquierdo

	        	if(k+1<=n && Heap[k+1]<Heap[k])

      	      	k=k+1;  // el hijo derecho es el menor

      	  	if(Heap[j]<Heap[k])

      	      	break;  // es menor que ambos hijos

      	  	t=Heap[j];  

      	  	Heap[j]=Heap[k];

        		Heap[k]=t;  

        		j=k;   // lo intercambiamos con el mayor hijo

      	}

      	return m;

	}	

}

