daily pastebin goal
75%
SHARE
TWEET

Untitled

a guest Sep 14th, 2018 54 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * To change this license header, choose License Headers in Project Properties.
  3.  * To change this template file, choose Tools | Templates
  4.  * and open the template in the editor.
  5.  */
  6. package ordenamientos;
  7.  
  8. import java.util.Random;
  9.  
  10. /**
  11.  * @param <E>
  12.  * @author Vanessa Gm
  13.  */
  14. public class Ordenamiento <E extends Comparable <E>> {
  15.     private double elementos[];
  16.  
  17.     /**
  18.      * Método constructor sin parámetros Crea un arreglo con 10 elementos
  19.      */
  20.     public Ordenamiento() {
  21.         elementos = new double[10];
  22.     }
  23.  
  24.     /**
  25.      * Método constructor con parámetro
  26.      *
  27.      * @param n número de elementos a ordenar
  28.      */
  29.     public Ordenamiento(int n) {
  30.         elementos = new double[n];
  31.     }
  32.  
  33.     public Ordenamiento(double [] arreglo){
  34.         elementos =  arreglo;
  35.     }
  36.  
  37.     /**
  38.      * Método para generar elementos aleatorios(desordenados) en el rango de
  39.      * 0-100 y llenar el arreglo con ellos
  40.      */
  41.     public void llenar() {
  42.         Random r = new Random();
  43.         for (int i = 0; i < elementos.length; i++) {
  44.             elementos[i] = r.nextDouble()*10 ;
  45.         }
  46.     }
  47.  
  48.     /**
  49.      * Método para imprimir los elementos del arreglo
  50.      */
  51.     public void imprimir() {
  52.         for (int i = 0; i < elementos.length; i++) {
  53.             System.out.print(elementos[i] + " - ");
  54.             if (i % 5 == 4) {
  55.                 System.out.println();
  56.             }
  57.         }
  58.     }
  59.  
  60.     /**
  61.      * Método para ordenar los elementos de la clase por intercambios
  62.      */
  63.     public void burbuja() {
  64.         for (int i = 1; i < elementos.length; i++) {
  65.             for (int j = 0; j < elementos.length - i; j++) {
  66.  
  67.                 if (elementos[j] > elementos[j + 1]) {
  68.                     double aux = elementos[j];
  69.                     elementos[j] = elementos[j + 1];
  70.                     elementos[j + 1] = aux;
  71.                 }
  72.                 imprimir();
  73.             }
  74.         }
  75.     }
  76.  
  77.     /**
  78.      * Método para ordenar los elementos de la clase por intercambios con la
  79.      * mejora de que si no ocurre intercambio alguno el algoritmo acaba
  80.      */
  81.     public void burbujaMejorado() {
  82.         boolean ordenado = false;
  83.         for (int i = 1; i < elementos.length && !ordenado; i++) {
  84.             ordenado = true;
  85.             for (int j = 0; j < elementos.length - i; j++) {
  86.                 if (elementos[j] > elementos[j + 1]) {
  87.                     ordenado = false;
  88.                     double aux = elementos[j];
  89.                     elementos[j] = elementos[j + 1];
  90.                     elementos[j + 1] = aux;
  91.                 }
  92.             }
  93.         }
  94.     }
  95.  
  96.     /**
  97.      * Método para ordenar los elementos de la clase por selección del mínimo
  98.      * elemento
  99.      */
  100.     public void seleccion() {
  101.         for (int i = 0; i < elementos.length; i++) {
  102.             int minimo = i;
  103.             for (int j = i + 1; j < elementos.length; j++) {
  104.                 if (elementos[j] < elementos[minimo]) {
  105.                     minimo = j;
  106.                 }
  107.             }
  108.             double aux = elementos[i];
  109.             elementos[i] = elementos[minimo];
  110.             elementos[minimo] = aux;
  111.             imprimir();
  112.         }
  113.     }
  114.  
  115.     /**
  116.      * Método para ordenar los elementos de la clase por inserccion de elementos
  117.      */
  118.     public void insercion() {
  119.         double aux;
  120.         for (int i = 1; i < elementos.length; i++) {
  121.             aux = elementos[i];
  122.             System.out.println("Aux: " + aux);
  123.             for (int j = i - 1; j >= 0 && elementos[j] > aux; j--) {
  124.                 System.out.println(j);
  125.                 elementos[j + 1] = elementos[j];
  126.                 elementos[j] = aux;
  127.                 imprimir();
  128.             }
  129.         }
  130.     }
  131.  
  132.     /**
  133.      * Método para ordenar los elementos de la clase por mezclas de sublistas
  134.      * ordenadas
  135.      */
  136.     public void mergesort(int init, int n) {
  137.         int n1;
  138.         int n2;
  139.         if (n > 1) {
  140.             n1 = n / 2;
  141.             n2 = n - n1;
  142.             mergesort(init, n1);
  143.             mergesort(init + n1, n2);
  144.             merge(init, n1, n2);
  145.         }
  146.     }
  147.  
  148.     /**
  149.      * Método para mezclar las dos sublistas generadas
  150.      */
  151.     private void merge(int init, int n1, int n2) {
  152.         double[] buffer = new double[n1 + n2];
  153.         int temp = 0;
  154.         int temp1 = 0;
  155.         int temp2 = 0;
  156.         int i;
  157.         while ((temp1 < n1) && (temp2 < n2)) {
  158.             if (elementos[init + temp1] < elementos[init + n1 + temp2]) {
  159.                 buffer[temp++] = elementos[init + (temp1++)];
  160.             } else {
  161.                 buffer[temp++] = elementos[init + n1 + (temp2++)];
  162.             }
  163.         }
  164.         while (temp1 < n1) {
  165.             buffer[temp++] = elementos[init + (temp1++)];
  166.         }
  167.         while (temp2 < n2) {
  168.             buffer[temp++] = elementos[init + n1 + (temp2++)];
  169.         }
  170.         for (i = 0; i < n1 + n2; i++) {
  171.             elementos[init + i] = buffer[i];
  172.         }
  173.     }
  174.  
  175.     public void quickSort(int left, int right) {
  176.         int index = partition(left, right);
  177.         if (left < index - 1) {
  178.             quickSort(left, index - 1);
  179.         }
  180.         if (index < right) {
  181.             quickSort(index, right);
  182.         }
  183.  
  184.     }
  185.  
  186.     private int partition(int left, int right) {
  187.          int i = left, j = right;
  188.         double tmp;
  189.         double pivot = elementos[(left + right) / 2];
  190.         while (i <= j) {
  191.             while (elementos[i] < pivot) {
  192.                 i++;
  193.             }
  194.             while (elementos[j] > pivot) {
  195.                 j--;
  196.             }
  197.             if (i <= j) {
  198.                 tmp = elementos[i];
  199.                 elementos[i] = elementos[j];
  200.                 elementos[j] = tmp;
  201.                 i++;
  202.                 j--;
  203.             }
  204.         }
  205.         return i;
  206.     }
  207. }
  208.    
  209. public class Ordenamiento implements Comparable<ClaseAComparar> {
  210.    
  211. @Override
  212. public int compareTo(ClaseAComparar a) {
  213. ...
  214. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top