Ordenar arreglos en java

UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA PROGRAMACION DE ALGORITMOS POR: Eylin Calderón Carrión. II Ciclo Sistemas Informáticos y Computación

Definición de Arreglo

Un arreglo o array es un conjunto de datos ordenados que está formado por un número fijo de elementos contiguos y de un mismo tipo, por lo cual son estructuras estáticas.

Los datos individuales que se encuentran en el arreglo se llaman elementos del arreglo.

Para definir un tipo estructurado arreglo, se debe especificar el tipo base y el número de elementos.

Los arreglos se clasifican en:

Unidimensionales (vectores o listas)

Multidimensionales ( tablas o matrices)

Declaración, inicialización y acceso

A los arreglos se los declara de la siguiente manera:

Tipo_dato nombre_array[ ]

Ejemplo: int meses_anio ];

Se inicializa de la siguiente manera:

nombre_array = tipo_dato [tamaño]

Ejemplo : meses _anio= new String [12];

Se accede al arreglo de la siguiente manera:

Nombre_array[ posición]

Ejemplo: meses[0] = “Enero”; meses[5] = “Junio”;

Clasificación de los Métodos de Ordenación de Arreglos

MÉTODOS DIRECTOS:

Método de Intercambio Directo / Burbuja

Método de Inserción Directa

Método de Selección Directa

MÉTODOS AVANZADOS

Método de ordenación rápida / QuickSort

Métodos Directos Método de Intercambio Directo / Burbuja Este método consiste en revisar cada elemento del arreglo que vaya a ser ordenado con el siguiente, intercambiándose de posición si están en el orden equivocado. Es necesario en este método revisar varias veces todo el arreglo hasta que no se necesiten más intercambios, lo que significa que el arreglo esta ordenado completamente. Este nombre de burbuja se dice por la forma con la que suben por los elementos de los arreglos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo, ya que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación siendo el más sencillo de usar. public void burbuja (int [] a){ for (int i=a.length-1; i>0; i--) for(int j=0; j<i; j++) if (a[ j ] > a[ j+1 ] ){ int temp = a[ j ]; a[ j ]= a[ j+1 ]; a[ j+1 ] = temp; } }

Métodos Directos Método de Inserción Directa Este método consiste en revisar cada elemento del arreglo que vaya a ser ordenado con el siguiente, intercambiándose de posición si están en el orden equivocado. Es necesario en este método revisar varias veces todo el arreglo hasta que no se necesiten más intercambios, lo que significa que el arreglo esta ordenado completamente. Este nombre de burbuja se dice por la forma con la que suben por los elementos de los arreglos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo, ya que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación siendo el más sencillo de usar.

public void selecciondirecta(int n) { int i,j,min,k; int cambio; for(i=0;i<n;i++) { min=arr[i]; k=0; cambio=0; for(j=i+1;j<n;j++) { if (arr[ j ]<min) { min=arr[ j ]; k=j; cambio=1;} } if (cambio ) { arr[ k ]=arr[ i ]; arr[ i ]=min; } } }

Métodos Directos Método de Selección Directa Este método consiste en recorrer un arreglo desde la primera posición hasta n-1, en cada ves que se recorre se busca encontrar el elemento más pequeño, de tal forma que después de la primera ves en la posición 0 este el elemento más pequeño de todo el arreglo; en la segunda ves el segundo elemento más pequeño y así sucesivamente hasta ordenar todos los elementos. Este método no es el más eficiente, pero es uno de lo más fáciles de implementar.

int i,j,aux; Se da valores a los elementos del arreglo for(i=1;i { // Se intenta añadir el elemento i. aux=array[i]; for(j=i-1;j>=0;j--) // Se recorre la sublista de atrás a adelante para buscar { // la nueva posición del elemento i. if(aux>array[j]) // Si se encuentra la posición: { array[j+1]=aux; // Colocarlo break; // y colocar el siguiente número. } else // si no, sigue buscándola. array[j+1]=array[j]; } if(j==-1) // si se ha buscado en todas las posiciones y no se ha encontrado la correcta array[0]=aux; // es que la posición es al principio del todo. }

Métodos Avanzados Método de Selección Directa / QuickSort

Este método consiste en resolver un problema a partir de la solución de subproblemas del mismo tipo, pero de menor tamaño. Si los subproblemas son todavía relativamente grandes se aplicará de nuevo esta técnica hasta alcanzar subproblemas lo suficientemente pequeños para ser solucionados directamente.

Se plantea el problema de forma que pueda ser descompuesto en k subproblemas del mismo tipo, pero de menor tamaño. Es decir, si el tamaño de la entrada es n, hemos de conseguir dividir el problema en k subproblemas, cada uno con una entrada de tamaño nk y donde 0 ≤ nk < n. A esta tarea se le conoce como división.

Se resuelven independientemente todos los subproblemas. El tamaño de los subproblemas debe ser menor que el tamaño original del problema.

Finalmente se deben combinar las soluciones obtenidas anteriormente para construir la solución del problema original.

public void quicksort ( int [] a, int izq, int der) { int i = izq; int j =der; int pivote = a[ (izq + der) / 2]; do{ while (a[ i ] < pivote) { i++ } while ( a[ j ]> pivote) { j— } if (i <= j) { int aux = a[ i ]; a[ i ] = a[ j ]; a[ j ] = aux; i++; j--; } } while (i <= j); if (izq < j) { quicksort(a, izq, j); } if (i < der) { quicksort(a, i, der); } }