Metodo de Ordenamiento en java

Los métodos de ordenamiento nos ayudan a visualizar de manera mas clara un arreglo o lista, ya sea que se requiera de manera ascendente o descendente, en java encontramos tres métodos bastantes conocidos comencemos por el mas básico.

Ordenamiento de burbuja.

Su nombre es básicamente por la manera en como trabaja el algoritmo de ordenamiento ya que se trata de tomar el peso de cada elemento y dejar que de esta manera se vaya pasando hasta que quede ordenado.

El código es el siguiente.

public int[] bubbleSort(int[] n){
   int tmp;
   int t = n.length;
   for( int i = 1; i < t; i ++ ){
        for( int k = t-1; k >= i; k --){
            if( n[k]<n[k-1]){
               tmp=n[k];
               n[k]=n[k-1];
               n[k-1]=tmp;
            }
        }
   }
   return n;
}

La invocacion sera la siguiente
int[] arrInt = {5,6,9,12,48,356,4,1,0,1574};
int[] rtnNumber = bubbleSort(arrInt);
dando como salida
run:
5,6,9,12,48,356,4,1,0,1574
0,1,4,5,6,9,12,48,356,1574
BUILD SUCCESSFUL (total time: 0 seconds)

Como les comentaba hace un momento existen otros dos métodos de ordenamiento muy conocidos entre ellos esta el llamado QickSort:

Basado en la tecnica Divide y Venceras, toma un elemento del arreglo (pivote) dejando los menores a el de un lado mientras que del otro lado los mayores a este. segementando el arreglo hasta que este quede ordenado.

El código es el siguiente.

---

    public void Quicksort(int[] vector, int first, int last) {
        int i = first, j = last;
        int pivote = vector[(first + last) / 2];
        int auxiliar;
        do {
            while (vector[i] < pivote) {
                i++;
            }
            while (vector[j] > pivote) {
                j--;
            }
            if (i <= j) {
                auxiliar = vector[j];
                vector[j] = vector[i];
                vector[i] = auxiliar;
                i++;
                j--;
            }
        } while (i <= j);

        if (first < j) {
            Quicksort(vector, first, j);
        }

        if (last > i) {
            Quicksort(vector, i, last);
        }
    }

---
El llamado sera el siguiente

int[] arr = {6, 5, 1, 3, 8, 4, 9, 7, 12, 45, 16, 83, 128, 0, 45};
Quicksort(arr, 0, arr.length - 1);

Dejando como salida el siguiente resultado
run:
6,5,1,3,8,4,9,7,12,45,16,83,128,0,45,
0,1,3,4,5,6,7,8,9,12,16,45,45,83,128,
BUILD SUCCESSFUL (total time: 0 seconds)

Ya por ultimo tenemos el siguiente método de ordenamiento HeapSort.

Este método se desarrolla de manera recursiva, no estable, consiste en almacenar todo el arreglo o elementos dentro de un vecotr a ordenar formando algo similar a un monticulo, llevando los menores de un lado y pasandolos  de derecha a izquierda en una estructura de tipo arbol.

El codigo es el siguiente

---

    public void fnSortHeap(int arr[], int arr2) {
        int i, o;
        int lCh, rCh, mCh, root, tmp;
        root = (arr2 - 1) / 2;
        for (o = root; o >= 0; o--) {
            for (i = root; i >= 0; i--) {
                lCh = (2 * i) + 1;
                rCh = (2 * i) + 2;
                if ((lCh <= arr2) && (rCh <= arr2)) {
                    if (arr[rCh] >= arr[lCh]) {
                        mCh = rCh;
                    } else {
                        mCh = lCh;
                    }
                } else {
                    if (rCh > arr2) {
                        mCh = lCh;
                    } else {
                        mCh = rCh;
                    }
                }

                if (arr[i] < arr[mCh]) {
                    tmp = arr[i];
                    arr[i] = arr[mCh];
                    arr[mCh] = tmp;
                }
            }
        }
        tmp = arr[0];
        arr[0] = arr[arr2];
        arr[arr2] = tmp;
    }

---
Quedando el llamado de la siguiente manera

int arr[] = {6, 5, 1, 3, 8, 4, 9, 7, 12, 45, 16, 83, 128, 0, 45};
for (i = arr.length; i > 1; i--) {
      app.fnSortHeap(arr, i - 1);
}

Dejando como salida el siguiente resultado
run:
---------------
6,5,1,3,8,4,9,7,12,45,16,83,128,0,45
0,1,3,4,5,6,7,8,9,12,16,45,45,83,128
---------------
BUILD SUCCESSFUL (total time: 0 seconds)

Sin mas por el momento espero esto les aya servido de ayuda en algo, de ser así me gustaria saber de tu experiencia con estos métodos, comparte con tus amigos este blog y no olvides seguirme para estar al día con las siguientes entradas.