Metodo QuickSort

Este método es una mejora sustancial del método de intercambio directo y recibe el nombre de Quick Sort por la velocidad con que ordena los elementos del arreglo. Su autor C.A. Hoare lo bautizó así.
La idea central de este algoritmo consiste en los siguiente:

• Se toma un elemento x de una posición cualquiera del arreglo.
• Se trata de ubicar a x en la posición correcta del arreglo, de tal forma que todos los elementos que se encuentran a su izquierda sean menores o iguales a x y todos los elementos que se encuentren a su derecha sean mayores o iguales a x.
• Se repiten los pasos anteriores pero ahora para los conjuntos de datos que se encuentran a la izquierda y a la derecha de la posición correcta de x en el arreglo.

Tiene aparentemente la propiedad de trabajar mejor para elementos de entrada desordenados completamente, que para elementos semiordenados. Esta situación es precisamente la opuesta al ordenamiento de burbuja.

Metodo burbuja en Java

public class Burbuja {
static int [] vec = {312, 614, 88, 22, 54};  
void ordenar (int [] v, int cant) {  
if (cant > 1) {  
for (int f = 0 ; f < cant - 1 ; f++)//  
if (v [f] > v [f + 1]) {  
int aux = v [f];  
v [f] = v [f + 1];  
v [f + 1] = aux;  
}  
ordenar (v, cant - 1);  
}  
}  
void imprimir () {  
for (int f = 0 ; f < vec.length ; f++)  
System.out.print (vec [f] + " ");  
System.out.println("\n");  
}  

public static void main (String [] ar) {  
Recursivdad r = new Burbuja();  
r.imprimir ();  
r.ordenar (vec, vec.length);  
r.imprimir ();  
}
}

Metodo burbuja

Este método consiste en acomodar el vector moviendo el mayor hasta la última casilla comenzando desde la casilla cero del vector hasta haber acomodado el número más grande el la última posición, una vez acomodado el más grande, prosigue a encontrar y acomodar el siguiente más grande comparando de nuevo los números desde el inicio del vector, y así sigue hasta ordenar todo los elementos el arreglo. Este algoritmo es muy deficiente ya que al ir comparando las casillas para buscar el siguiente más grande, éste vuelve a comparar las ya ordenadas. A pesar de ser el algoritmo de ordenamiento más deficiente que hay, éste es el más usado en todos los lenguajes de programación.


El procedimiento de la burbuja es el siguiente:

• Ir comparando desde la casilla 0 numero tras número hasta encontrar uno mayor, si este es realmente el mayor de todo el vector se llevará hasta la última casilla, si no es así, será reemplazado por uno mayor que él.
• Este procedimiento seguirá así hasta que halla ordenado todas las casillas del vector.

Una de las deficiencias del algoritmo es que ya cuando a ordenado parte del vector vuelve a compararlo cuando esto ya no es necesario.

Ventajas:
•Bastante sencillo y mas utilizado por su fácil comprensión y programación
•Código reducido
•Eficaz.


Desventajas:
•Consume bastante tiempo calculo computarizado.
•Requiere de muchas lecturas/escrituras en memoria

Una de las deficiencias del algoritmo es que ya cuando a ordenado parte del vector vuelve a compararlo cuando esto ya no es necesario.

Numeros de Fibonacci en java

 public class fibonacci {

 public int fibonaci (int n, int fibinf, int fibsup)

{

    Scanner teclado = new Scanner (System.in);
    System.out.println("Ingrese el numero");
    n = teclado.nextInt();
    System.out.println("--------------------");
    if ((n==0)||(n==1))
    {
    System.out.println("La suma es " + n);
    return n;
     }

    fibinf = 0;
    fibsup = 1;
    for (int i = 2; i<n; i++) {
     int x;
     x = fibinf;
     fibinf = fibsup;
     fibsup = x + fibinf;
     System.out.println(" "+fibsup);
    }
     return (fibsup);
   
}
     public static void main(String[] args)

     {

      fibonacci fb = new fibonacci ();

      int n =0, fibinf =0, fibsup = 1;

      fb.fibonaci(n, fibinf, fibsup);

      }
 }

Numero de Fibonacci

Leonardo Fibonacci, también llamado Leonardo Pisano, fue un calculista que nació y murió en la ciudad de Pisa, en Italia, del 1175 a 1240. Dedicó su vida a recopilar todas las enseñanzas que recogió en sus numerosos viajes al mundo árabe, de quienes difundió sus principios de cálculo en el mundo occidental. 

Los conocidos como Números Fibonachi, fueron un intento de describir el crecimiento de una población teniendo en cuenta que cada individuo tendría dos hijos a lo largo de su vida.

Consta de una serie de números naturales que se suman de a 2, a partir de 0 y 1. Básicamente, la sucesión de Fibonacci se realiza sumando siempre los últimos 2 números (Todos los números presentes en la sucesión se llaman números de Fibonacci) de la siguiente manera:

0,1,1,2,3,5,8,13,21,34...

Fácil, ¿no? (0+1=1 / 1+1=2 / 1+2=3 / 2+3=5 / 3+5=8 / 5+8=13 / 8+13=21 / 13+21=34...) Así sucesivamente, hasta el infinito. Por regla, la sucesión de Fibonacci se escribe así:

xn = xn-1 + xn-2.

Recursividad

Recursividad
Propiedad que posee un metodo por la cual puede llamarse a sí mismo. un metodo tiene sentencias entre las que se encuentran al menos una llamada al propio metodo.

Metodos recursivos:

• Factorial
• Torres de Hanoi
• Ajedrez
• Black Jack
• Fibonacci.

Codigo Arbol

import java.util.Scanner;

public class Arbol {
    class Nodo
    {
        int info;
        Nodo izq, der;
    }
    Nodo raiz;
    int cant;
    int altura;
    public Arbol() {
        raiz=null;
    }
    public void insertar (int info) {
        if (!existe(info)) {
            Nodo nuevo;
            nuevo = new Nodo ();
            nuevo.info = info;
            nuevo.izq = null;
              nuevo.der = null;
            if (raiz == null)
                raiz = nuevo;
            else {
                Nodo anterior = null, reco;
                reco = raiz;
                while (reco != null)  {
                    anterior = reco;
                    if (info < reco.info)
                        reco = reco.izq;
                    else
                        reco = reco.der;
                }
                if (info < anterior.info)
                    anterior.izq = nuevo;
                else
                    anterior.der = nuevo;
            }
        }
    }
    public boolean existe(int info) {
        Nodo reco=raiz;
        while (reco!=null) {
            if (info==reco.info)
                return true;
            else
                if (info>reco.info)
                    reco=reco.der;
                else
                    reco=reco.izq;
        }
        return false;
    }
    private void imprimirEntre (Nodo reco)  {
        if (reco != null)  {
            imprimirEntre (reco.izq);
            System.out.print(reco.info + " ");
            imprimirEntre (reco.der);
        }
    }
    public void imprimirEntre () {
        imprimirEntre (raiz);
        System.out.println();
    }

    private void cantidad(Nodo reco) {
        if (reco!=null) {
            cant++;
            cantidad(reco.izq);
            cantidad(reco.der);
        }
    }
    public int cantidad() {
        cant=0;
        cantidad(raiz);
        return cant;
    }
    private void cantidadNodosHoja(Nodo reco) {
        if (reco!=null) {
            if (reco.izq==null && reco.der==null)
                cant++;
            cantidadNodosHoja(reco.izq);
            cantidadNodosHoja(reco.der);
        }
    }
    public int cantidadNodosHoja() {
        cant=0;
        cantidadNodosHoja(raiz);
        return cant;
    }
    private void imprimirEntreConNivel (Nodo reco,int nivel)  {
        if (reco != null) {
            imprimirEntreConNivel (reco.izq,nivel+1);
            System.out.print(reco.info + " ("+nivel+") - ");
            imprimirEntreConNivel (reco.der,nivel+1);
        }
    }
    public void imprimirEntreConNivel () {
        imprimirEntreConNivel (raiz,1);
        System.out.println();
    }
    private void retornarAltura (Nodo reco,int nivel)    {
        if (reco != null) {
            retornarAltura (reco.izq,nivel+1);
            if (nivel>altura)
                altura=nivel;
            retornarAltura (reco.der,nivel+1);
        }
    }
    public  int retornarAltura () {
        altura=0;
        retornarAltura (raiz,1);
        return altura;
    }
    public void mayorValorl() {
        if (raiz!=null) {
            Nodo reco=raiz;
            while (reco.der!=null)
                reco=reco.der;
            System.out.println("Mayor valor del irbol:"+reco.info);
        }
    }
    public void borrarMenor() {
        if (raiz!=null) {
            if (raiz.izq==null)
                raiz=raiz.der;
            else {
                Nodo atras=raiz;
                Nodo reco=raiz.izq;
                while (reco.izq!=null) {
                    atras=reco;
                    reco=reco.izq;
                }
                atras.izq=reco.der;
            }
        }
    }
    public static void main (String [] ar)
    {
        Scanner leer=new Scanner(System.in);
        int opc1;
        String opc2;
        Arbol abo = new Arbol ();
        do{
            System.out.println("Ingrese dato");
            opc1=leer.nextInt();
            abo.insertar(opc1);
            System.out.println("Desea introducir otro dato?\na)Si b)No");
            opc2=leer.next();
           
        }while(opc2!="a");

        System.out.println ("Impresion entreorden: ");
        abo.imprimirEntre ();
        System.out.println ("Cantidad de nodos del irbol:"+abo.cantidad());
        System.out.println ("Cantidad de nodos hoja:"+abo.cantidadNodosHoja());
        System.out.println ("Impresion en entre orden junto al nivel del nodo.");
        abo.imprimirEntreConNivel();
        System.out.print ("Artura del arbol:");
        System.out.println(abo.retornarAltura());
        abo.mayorValorl();
        abo.borrarMenor();
        System.out.println("Luego de borrar el menor:");
        abo.imprimirEntre ();
    }
}