/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ordenamientos;

import java.util.Random;

/**
 * @param <E>
 * @author Vanessa Gm
 */
public class Ordenamiento <E extends Comparable <E>> {
    private double elementos[];

    /**
     * Método constructor sin parámetros Crea un arreglo con 10 elementos
     */
    public Ordenamiento() {
        elementos = new double[10];
    }

    /**
     * Método constructor con parámetro
     *
     * @param n número de elementos a ordenar
     */
    public Ordenamiento(int n) {
        elementos = new double[n];
    }

    public Ordenamiento(double [] arreglo){
        elementos =  arreglo;
    }

    /**
     * Método para generar elementos aleatorios(desordenados) en el rango de
     * 0-100 y llenar el arreglo con ellos
     */
    public void llenar() {
        Random r = new Random();
        for (int i = 0; i < elementos.length; i++) {
            elementos[i] = r.nextDouble()*10 ;
        }
    }

    /**
     * Método para imprimir los elementos del arreglo
     */
    public void imprimir() {
        for (int i = 0; i < elementos.length; i++) {
            System.out.print(elementos[i] + " - ");
            if (i % 5 == 4) {
                System.out.println();
            }
        }
    }

    /**
     * Método para ordenar los elementos de la clase por intercambios
     */
    public void burbuja() {
        for (int i = 1; i < elementos.length; i++) {
            for (int j = 0; j < elementos.length - i; j++) {

                if (elementos[j] > elementos[j + 1]) {
                    double aux = elementos[j];
                    elementos[j] = elementos[j + 1];
                    elementos[j + 1] = aux;
                }
                imprimir();
            }
        }
    }

    /**
     * Método para ordenar los elementos de la clase por intercambios con la
     * mejora de que si no ocurre intercambio alguno el algoritmo acaba
     */
    public void burbujaMejorado() {
        boolean ordenado = false;
        for (int i = 1; i < elementos.length && !ordenado; i++) {
            ordenado = true;
            for (int j = 0; j < elementos.length - i; j++) {
                if (elementos[j] > elementos[j + 1]) {
                    ordenado = false;
                    double aux = elementos[j];
                    elementos[j] = elementos[j + 1];
                    elementos[j + 1] = aux;
                }
            }
        }
    }

    /**
     * Método para ordenar los elementos de la clase por selección del mínimo
     * elemento
     */
    public void seleccion() {
        for (int i = 0; i < elementos.length; i++) {
            int minimo = i;
            for (int j = i + 1; j < elementos.length; j++) {
                if (elementos[j] < elementos[minimo]) {
                    minimo = j;
                }
            }
            double aux = elementos[i];
            elementos[i] = elementos[minimo];
            elementos[minimo] = aux;
            imprimir();
        }
    }

    /**
     * Método para ordenar los elementos de la clase por inserccion de elementos
     */
    public void insercion() {
        double aux;
        for (int i = 1; i < elementos.length; i++) {
            aux = elementos[i];
            System.out.println("Aux: " + aux);
            for (int j = i - 1; j >= 0 && elementos[j] > aux; j--) {
                System.out.println(j);
                elementos[j + 1] = elementos[j];
                elementos[j] = aux;
                imprimir();
            }
        }
    }

    /**
     * Método para ordenar los elementos de la clase por mezclas de sublistas
     * ordenadas
     */
    public void mergesort(int init, int n) {
        int n1;
        int n2;
        if (n > 1) {
            n1 = n / 2;
            n2 = n - n1;
            mergesort(init, n1);
            mergesort(init + n1, n2);
            merge(init, n1, n2);
        }
    }

    /**
     * Método para mezclar las dos sublistas generadas
     */
    private void merge(int init, int n1, int n2) {
        double[] buffer = new double[n1 + n2];
        int temp = 0;
        int temp1 = 0;
        int temp2 = 0;
        int i;
        while ((temp1 < n1) && (temp2 < n2)) {
            if (elementos[init + temp1] < elementos[init + n1 + temp2]) {
                buffer[temp++] = elementos[init + (temp1++)];
            } else {
                buffer[temp++] = elementos[init + n1 + (temp2++)];
            }
        }
        while (temp1 < n1) {
            buffer[temp++] = elementos[init + (temp1++)];
        }
        while (temp2 < n2) {
            buffer[temp++] = elementos[init + n1 + (temp2++)];
        }
        for (i = 0; i < n1 + n2; i++) {
            elementos[init + i] = buffer[i];
        }
    }

    public void quickSort(int left, int right) {
        int index = partition(left, right);
        if (left < index - 1) {
            quickSort(left, index - 1);
        }
        if (index < right) {
            quickSort(index, right);
        }

    }

    private int partition(int left, int right) {
         int i = left, j = right;
        double tmp;
        double pivot = elementos[(left + right) / 2];
        while (i <= j) {
            while (elementos[i] < pivot) {
                i++;
            }
            while (elementos[j] > pivot) {
                j--;
            }
            if (i <= j) {
                tmp = elementos[i];
                elementos[i] = elementos[j];
                elementos[j] = tmp;
                i++;
                j--;
            }
        }
        return i;
    }
}

public class Ordenamiento implements Comparable<ClaseAComparar> {

@Override
public int compareTo(ClaseAComparar a) {
...
}