Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- /*
- * 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) {
- ...
- }
Add Comment
Please, Sign In to add comment