jueves, 4 de mayo de 2017

Método de Ordenamiento Burbuja


Metodo burbuja 
Gonzales Ramírez Ian Alexander
Armenta Almaguer Uriel Antonio de Jesús
Escalante Bravo Oscar Mauricio
Estrada Ibarra Sandra Lizette

Martínez de Jesús Luis Antonio   



 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.

En el siguiente enlace puedes descargar nuestra presentación donde tendrás el acceso a la información y guía de como hacer el método burbuja: Presentacion del Método burbuja

En esta parte te dejaremos  el código de nuestro método para que puedas agregarlo mas tarde y poder darle un vistazo :Código del Método




                

Método de Ordenamiento por Inserción

Inserción
Mario Alberto Hernández Torres
Cruz Isaac Aranda Cervantes
Saulo David García Valadez
José Guadalupe Aguao Bustos
Eduardo Flores Arias

La Inserción es un Método de Ordenamiento que se usa para ordenar datos generados por un arreglo de manera desordenada o al azar usando un algoritmo de comparación entre elementos.
Es muy sencillo en cualquier lenguaje de programación y fácil de comprender por el usuario.
Código 🔜


Presentacion Power Point 🔜

Método de Ordenamiento por Selección

Equipo 3
Conformado por:
Carlos Andrés Garza Jiménez
Guadalupe Felicitas Castillo López
Gerardo Yannick Lara Gómez
Juan Alejandro Aguilera Cárdenas
Edith Marlett Díaz Machuca

Presentando el tema de: "Método de Ordenamiento por Selección"


Método de Ordenamiento Shell (Shell Sort)

Equipo de Ordenamiento Shell en Netbeans del grupo 402

Integrantes:
Francisco Bernardo Arenas Galvan
Diana Isabel cruz Camarillo
Luis Arturo Hernández Martínez
Johan Alejandro Flores Martínez
Karla Berenice Díaz Martínez
Martha Baeza Rocha



Presentación del equipo que contiene mas información sobre el método Shell
Descargar presentación de método Shell

Este es el programa del método Shell, copiado en bloc de notas, para poder utilizarlo deben de copiarlo en algún programa de netbeans.

Programa

clase principal del programa



Página web del método de ordenamiento Shell
(carpeta con páginas html, imágenes y gifs, propios de la página).

Gracias por ver nuestro método.

Método de Ordenamiento por Mezclas (Merge Sort)

Equipo 5 (Merge-Sort)

Integrantes:

-Liliana Guadalupe Vera Zapata
-Cristian Jareth Santibáñez Ramírez  
-Leonardo Javier Ortega Cabrera
-Eduardo David Ponce Ramírez
-Diego Armando Vallejo Ayala
-Néstor Javier Romero Flores


El algoritmo de ordenamiento por mezcla (merge sort en inglés) es un algoritmo de ordenamiento externo estable basado en la técnica divide y vencerás.
  1. Si la lista es pequeña (vacía o de tamaño 1) ya está ordenada y no hay nada que hacer. De lo contrario hacer lo siguiente:
  1. Dividir la lista al medio, formando dos sublistas de (aproximadamente) el mismo tamaño cada una.
  1. Ordenar cada una de esas dos sublistas (usando este mismo método).
  1. Una vez que se ordenaron ambas sublistas, intercalarlas de manera ordenada.

Este método se basa en la siguiente idea:
Por ejemplo, si la lista original es [6, 7, -1, 0, 5, 2, 3, 8] deberemos ordenar recursivamente [6, 7, -1, 0] y [5, 2, 3, 8] con lo cual obtendremos [-1, 0, 6, 7] y [2, 3, 5, 8]. Si intercalamos ordenadamente las dos listas ordenadas obtenemos la solución buscada: [-1, 0, 2, 3, 5, 6, 7, 8].

Codigo Merge-Sort
package javaapplication1;
// fichero Mergesort.java

import java.util.Date;

public class JavaApplication1 {

    public static void main(String [] arg) {
        int n = 10000;
        // generar n números aleatoriamente
        int [] v = new int[n];
        for (int i=1; i<n; i++) {
            v[i] = (int) (Math.random()*100);
        }
        
        System.out.println("Vector antes de ordenar:"); 
        for (int i=1; i<n; i++) {
            System.out.println("v["+i+"] = "+v[i]);
        }
        // ordenar los números
        Date antes = new Date();
        mergesort(v, n);
        Date despues = new Date();
        long etime = despues.getTime()-antes.getTime();
        System.out.println("\nTiempo utilizado por mergesort(): " +
                           etime + " milisegundos.");
        
        System.out.println("\nVector despues de ordenar:"); 
       for (int i=0; i<n; i++) {
            System.out.println("v["+i+"] = "+v[i]);
        }
        System.out.println("Ya he terminado.");
    } // fin de main()

    // mezclar ordenadamente dos ficheros ordenados
    // na, nb número de elementos de los conjuntos a y b
    // ia, ib, ic posición donde empiezan los conjuntos en 
    //     los vectores a[], b[] y c[]
    static void merge(int a[], int ia, int b[], int ib, 
                      int c[], int ic, int na, int nb)
    {
        int i=ia, j=ib, k=ic;
        // copiar ordenadamente a y b sobre c
        while (i<na+ia && j<nb+ib) {
            if (a[i] < b[j]) {
                c[k++] = a[i++];
            }
            else {
                c[k++] = b[j++];
            }
        }
        
        while (i<na+ia) {
            c[k++] = a[i++];
        }

        while (j<nb+ib) {
            c[k++] = b[j++];
        }
    } // fin de merge()


    public static void mergesort(int vect[], int n)
    {
        // se supone que n debe ser potencia de 2
        int [] aux = new int[n];

        // valores de k: 1, 2, 4, 8, ...
        for (int k=1; k<n; k*=2) {
            // valores de j = 0, 2, 4, 6, 8, ... (k=1)
            //            j = 0, 4, 8,12,16, ... (k=2)
            //for (j = 0; j<n-k; j+=2*k) // para n potencia de 2
            for (int j = 0; j<=n-k; j+=2*k) {
                merge( vect, j, vect, j+k, aux, j, 
                      Math.min(k,n-j), Math.min(k,n-j-k) );
            }
            System.arraycopy(aux, 0, vect, 0, n);
        }
        aux = null;
    } // fin de mergesort()

} // fin de la clase Mergesort


Animacion de Merge Sort




 

Método de Ordenamiento Rápido (Quick Sort)

Método  Quicksort 

Creación
Desde que existe la ciencia de la computación, uno de los mayores problemas con los que los ingenieros se encontraban en su día a día, era el de ordenar listas de elementos. Por su causa, diversos algoritmos de ordenación fueron desarrollados a lo largo de los años y siempre existió un intenso debate entre los desarrolladores sobre cual de todos los algoritmos de ordenación era el más rápido.
El debate finalizó abruptamente en 1960 cuando Sir Charles Antony Richard Hoare desarrolló el algoritmo de ordenación Quicksort, este es el algoritmo de ordenación más rápido. 

¿En que se basa el quicksort?
Se basa en la técnica divide y vencerás, que consiste en ir subdividiendo el array en arrays más pequeños, y ordenar éstos. Para hacer esta división, se toma un valor del array como pivote, y se mueven todos los elementos menores que este pivote a su izquierda, y los mayores a su derecha. A continuación se aplica el mismo método a cada una de las dos partes en las que queda dividido el array.

Características del Algoritmo QuickSort
En la práctica, es el algoritmo de ordenación más rápido conocido, su tiempo de ejecución promedio es O(n log (n)), siendo en el peor de los casos O(n2), caso altamente improbable. El hecho de que sea más rápido que otros algoritmos de ordenación con tiempo promedio de O(n log (n)) ( como SmoothSort o HeapSort ) viene dado por que QuickSort realiza menos operaciones ya que el método utilizado es el de partición.
Los pasos que realiza este algoritmo son:
1. Selecciona un valor del arreglo como pivote es decir un numero por el cual todos los elementos van a ser comparados.
2. Se realizan dos búsquedas: una de izquierda a derecha, buscando un elemento mayor que el pivote, y otra de derecha a izquierda, buscando un elemento menor que el pivote. Cuando se han encontrado los dos, se intercambian, y se sigue realizando la búsqueda hasta que las dos búsquedas se encuentran.
3. Luego se organizan los subarreglos que quedaron a mano derecha y izquierda.

Eligiendo el Pivote
La elección del pivote determina las particiones de la lista de datos, por lo tanto es importante intentar que al seleccionar el pivote v las particiones L1 y L3 tengan un tamaño idéntico dentro de lo posible.


De forma gráfica el proceso sería el siguiente:









En código así: 
Clase!
package programa.quicksort.pkg1;


public class Clase {
    
    public int [] quicksort(int numeros[])
{
return quicksort(numeros,0,numeros.length-1);
}

public int [] quicksort (int numeros[],int izq, int der)
{
if(izq>=der)
return numeros;
int i=izq,d=der;
if(izq!=der)
{
//Pivote Centro de pila
int pivote;
int aux;
pivote = izq;
while(izq!=der)
{//imprimirArreglo(numeros);

while(numeros[der]>=numeros[pivote] && izq<der)
der--;
while(numeros[izq]<numeros[pivote] && izq<der)

izq++;
if(der!=izq) {
aux = numeros[der];
numeros[der]= numeros[izq];
numeros[izq]=aux;
}
}
if(izq==der){
quicksort(numeros,i,izq-1);
quicksort(numeros,izq+1,d);
}
}
else
return numeros;
return numeros;

}

private void imprimirArreglo(int arreglo[] )
{
String imp="";
for (int i=0; i<arreglo.length;i++)
{
if(i!=arreglo.length-1)
imp=imp+arreglo[i]+"\n";
else
imp=imp+arreglo[i]+"";
}
System.out.println(imp);

}
}


main!
public static void main(String[] args) {
          long inicio, fin,tiempo;
        inicio= System.currentTimeMillis();
        Clase a = new Clase();
       int array[] = new int[1000];
     for (int x = 0; x<1000; x++){
     array[x]= (int)(Math.random()*100) ;
         System.out.println(x+".- "+array[x]);
     }
        System.out.println("Ahora te lo voy a ordenar, sale???");
     
     a.quicksort(array,0,999);
     for (int x = 0; x<1000; x++){
         System.out.println(x+".- "+array[x]);
     }
     fin=System.currentTimeMillis();
     tiempo=fin-inicio;
        System.out.println("Finalizado en: "+tiempo);
    }
}

   

Método de Ordenamiento por Casilleros (Bucket Sort)


Clasificación de cubo es un algoritmo de comparación de clasificación que opera en elementos dividiéndolos en diferentes cubos y luego la clasificación de estos cubos individualmente. Cada cubo se clasifica individualmente usando un algoritmo de clasificación separado o aplicando el algoritmo de clasificación de cubo remisivamente. El ordenamiento de la cuchara es útil principalmente cuando la entrada está distribuida uniformemente en un intervalo.



"Cada casillero sólo puede contener los elementos que cumplan unas determinadas condiciones. En el ejemplo esas condiciones son intervalos de números. Las condiciones deben ser excluyentes entre sí, para evitar que un elemento pueda ser clasificado en dos casilleros distintos"


Link del programa a Netbeans:
https://mega.nz/#F!8eomlJra!2rhcgFBGignDZDsc-jV3rA

Presentación: (copiar el enlace).
https://mega.nz/#!wH5nxChL!7au1Zi120Hj4AQEEt0v7mUXZxBfBPl7zXLLU4r-clN4