Algoritmos de ordenamiento

Algoritmos de ordenamiento

1. Método de la Burbuja

   • Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado.
   • También es conocido como el método del intercambio directo
     • Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.
   • EXPLICACIÓN
     • Ordeamos de forma ascendente
       • • Después vamos a recorrer la matriz
           • • Utilizamos un for anidado para comparar los valores contenidos en la matriz
               • • Si i = 0 el valor es 34 al entrar al segundo for el valor j = i + 1 será en este caso j = 1…
                   • • Si el valor de nums[j] es menor que el valor de nums[i] este se intercambiará de la siguiente forma, si queremos ordenar de manera Descendente solo tenemos que cambiar este signo.
                       • • Se guarda en un auxiliar para no perder el valor y volver a utilizarlo
                           • • En las dos líneas anteriores lo que hicimos fue intercambiar valores con el fin de ordenarlos, por último vamos a imprimir la matriz.
                               • Finalmente se imprime:

2. Método 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.
     • Suponiendo que tomamos como pivote el primer elemento, el método Quicksort que implementa este algoritmo de ordenación para ordenar un array de enteros se presenta a continuación.
       • EXPLICACIÓN
         • public static void quicksort(int A[], int izq, int der) {
           • int pivote=A[izq];
             • tomamos primer elemento como pivote
             • int i=izq;
               • int j=der;
                 • int aux;
                   • while(i<j){
                     • while(A[i]<=pivote && i<j) i++;
                       • while(A[j]>pivote) j--;
                         • if (i<j) {
                           • aux= A[i];
                             • los intercambia
                             • A[i]=A[j];
                               • A[j]=aux; } }
                                 • A[izq]=A[j];
                                   • se coloca el pivote en su lugar de forma que tendremos
                                   • A[j]=pivote;
                                     • los menores a su izquierda y los mayores a su derecha
                                     • if(izq<j-1)
                                       • quicksort(A,izq,j-1);
                                         • ordenamos subarray izquierdo
                                         • if (j+1 <der)
                                           • quicksort(A,j+1,der); }
                                             • ordenamos subarray derecho
                           • si no se han cruzado
                         • busca elemento menor que pivote
                       • busca elemento mayor que pivote
                     • mientras no se crucen las búsquedas
                 • j realiza la búsqueda de derecha a izquierda
               • i realiza la búsqueda de izquierda a derecha

3. Andrea Galán Galván

   • 110028863

Bilder und Dateien der Mindmap