document.write('
Data hosted with ♥ by Pastebin.com - Download Raw - See Original
  1. /* AUTOR: d3n3k4 (Dnk!)
  2.  * FECHA: 06/DIC/2010
  3.  * DESCRIPCION:
  4.         - Clase con distintos metodos de ordenacion, inserccion directa, seleccion
  5.           directa,burbuja y bublesort,shellsort.
  6.  * NOTA: Este codigo es libre y puede ser usado,modificado... siempre y cuando se
  7.  *       mantenga los creditos y comentarios del autor.
  8.  */
  9. public class algoritmosOrdenacion {
  10.     /*
  11.      * Ordenamiento Simple por Insercion directa.
  12.      */
  13.     public static int[] insercionDirecta(int[] vDesordenado) {
  14.         int temp,k;
  15.         for (int i = 1; i < vDesordenado.length;i++) {
  16.             temp = vDesordenado[i];
  17.             k = i - 1;
  18.             while (k >= 0 && vDesordenado[k] > temp) {
  19.                 vDesordenado[k+1] = vDesordenado[k];
  20.                 k--;
  21.             }
  22.             vDesordenado[k+1] = temp;
  23.         }
  24.         return vDesordenado;
  25.     }
  26.     /*
  27.      * Ordenamiento Simple por Seleccion directa.
  28.      */
  29.     public static int[] seleccionDirecta(int[] vDesordenado) {
  30.         int i,temp;
  31.         for (int k = 0; k < vDesordenado.length - 1;k++) {
  32.             i = k;
  33.             temp = vDesordenado[k];
  34.             for (int j = k + 1; j < vDesordenado.length; j++) {
  35.                 if (vDesordenado[j] < temp) {
  36.                     i = j;
  37.                     temp = vDesordenado[i];
  38.                 }
  39.             }
  40.             vDesordenado[i] = vDesordenado[k];
  41.             vDesordenado[k] = temp;
  42.         }
  43.         return vDesordenado;
  44.     }
  45.     /*
  46.      * Ordenamiento por intercambio directo (Burbuja).
  47.      */
  48.     public static int[] intercambioDirecto(int[] vDesordenado) {
  49.         int temp;
  50.         for (int i = 1; i < vDesordenado.length; i++) {
  51.             for (int j = vDesordenado.length - 1; j >= i ; j--) {
  52.                 if (vDesordenado[j] < vDesordenado[j-1]) {
  53.                     temp = vDesordenado[j];
  54.                     vDesordenado[j] = vDesordenado[j-1];
  55.                     vDesordenado[j-1] = temp;
  56.                 }
  57.             }
  58.         }
  59.         return vDesordenado;
  60.     }
  61.     /*
  62.      * Ordenamiento por burbuja optimizado (Bublesort).
  63.      */
  64.     public static int[] intercambioDirectoOptimizado(int[] vDesordenado) {
  65.         int temp;
  66.         for (int i = 0; i < vDesordenado.length; i++) {
  67.             for (int j = 0; j < i ; j++) {
  68.                 if (vDesordenado[i] < vDesordenado[j]) {
  69.                     temp = vDesordenado[j];
  70.                     vDesordenado[j] = vDesordenado[i];
  71.                     vDesordenado[i] = temp;
  72.                 }
  73.             }
  74.         }
  75.         return vDesordenado;
  76.     }
  77.     /*
  78.      * Ordenamiento por mezcla, optimizado de inserccion directa.
  79.      */
  80.     public static int[] shellSort(int[] vDes) {
  81.         for ( int increment = vDes.length / 2; increment > 0; increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) {
  82.             for (int i = increment; i < vDes.length; i++) {
  83.                 for (int j = i; j >= increment && vDes[j - increment] > vDes[j]; j -= increment) {
  84.                     int temp = vDes[j];
  85.                     vDes[j] = vDes[j - increment];
  86.                     vDes[j - increment] = temp;
  87.                 }      
  88.             }
  89.         }
  90.         return vDes;
  91.     }
  92. }
');