Tecnológico Nacional de México

Instituto Tecnológico de Acapulco

Estructura de datos

10:00-11:00

Unidad 5

Algoritmos de ordenamiento

Docente

Luis Ramos Baños

Alumno

Martínez Gómez Óscar Iván 20321106

Carrera

Ing. En Sistemas Computacionales

Grupo: IS3

Acapulco, Guerrero

Fecha de entrega: 3 diciembre del 2021

Introducción
Los algoritmos de ordenamiento nos permiten, como su nombre lo dice,
ordenar información de una manera especial basándonos en un criterio de
ordenamiento.

Dentro de la materia el ordenamiento de datos cumple un rol muy importante,

ya sea como un fin en sí o como parte de otros procedimientos más complejos.
Se han desarrollado distintos métodos, cada uno con características específicas,
y con ventajas y desventajas sobre las demás.

-1-
 ealizar un programa en java donde aplique los algoritmos de ordenamiento
como: Burbuja, QuickSort, ShellSort, Radix

El programa creará un arreglo unidimensional de 1000 espacios, donde se

llenaran en forma automática con números aleatorios del 1 al 5000 el proceso
validará que no haya numero repetidos dentro del arreglo (Carga de datos).

El programa tendrá las siguientes opciones:

1. Carga de datos
2. Algoritmo de ordenamiento Burbuja
3. Algoritmo de ordenamiento QuickSort
4. .- Algoritmo de ordenamiento ShelSort
5. .- Algoritmo de ordenamiento Radix
6. .- Salir

Cada opción ordenará el arreglo creado, imprimiendo el arreglo

origina(desordenado) y el arreglo Ordenado en forma paralela, también mostrará
el numero de iteraciones que al algoritmo generó para poder ordenar el arreglo.

-2-
 A continuación se presenta una breve descripción sobre como operan cada
uno los algoritmos de ordenamiento:

Ordenamiento por BubbleShort

El ordenamiento por burbuja es el algoritmo más sencillo. Consiste en ciclar

repetidamente a través de la lista, comparando elementos adyacentes de dos
en dos. Si un elemento es mayor que el que está en la siguiente posición se
intercambian. Es un algoritmo estable. El inconveniente es que es muy lento.

Ordenamiento por QuickSort

Es un algoritmo basado en la técnica de divide y vencerás, que permite, en

promedio, ordenar n elementos en un tiempo proporcional a n log n.

El algoritmo consta de los siguientes pasos:

Elegir un elemento de la lista de elementos a ordenar, al que llamaremos

pivote.

Resituar los demás elementos de la lista a cada lado del pivote, de manera
que a un lado queden todos los menores que él, y al otro los mayores. Los
elementos iguales al pivote pueden ser colocados tanto a su derecha como a
su izquierda, dependiendo de la implementación deseada. En este momento,
el pivote ocupa exactamente el lugar que le corresponderá en la lista ordenada.

La lista queda separada en dos sublistas, una formada por los elementos a
la izquierda del pivote, y otra por los elementos a su derecha.

Repetir este proceso de forma recursiva para cada sublista mientras éstas
contengan más de un elemento. Una vez terminado este proceso todos los
elementos estarán ordenados.

-3-
 .- Algoritmo de ordenamiento ShelSort

El método se denomina así en honor de su inventor Donald Shell. Su

implementación original, requiere O(n2) comparaciones e intercambios en el
peor caso, aunque un cambio menor presentado en el libro de V. Pratt produce
una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto
es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero
peor que el óptimo O(n log n).

El Shell sort es una generalización del ordenamiento por inserción, teniendo

en cuenta dos observaciones: El ordenamiento por inserción es eficiente si la
entrada está "casi ordenada". El ordenamiento por inserción es ineficiente, en
general, porque mueve los valores sólo una posición cada vez.

Algoritmo de ordenamiento Radix

En informática, el ordenamiento Radix (radix sort en inglés) es un algoritmo

de ordenamiento que ordena enteros procesando sus dígitos de forma
individual. Como los enteros pueden representar cadenas de caracteres (por
ejemplo, nombres o fechas) y, especialmente, números en punto flotante
especialmente formateados, radix sort no está limitado sólo a los enteros.

-4-
Metodo burbuja

//Metodo Burbuja
public static void Burbuja(){
int temporal;
int tamaño = aleatorios.length;
for (int i = 1; i < tamaño; i++) {
for (int k = tamaño - 1; k >= i; k--) {
if(aleatorios[k] < aleatorios[k-1]){
temporal = aleatorios[k];
aleatorios[k] = aleatorios[k-1];
aleatorios[k-1]= temporal;
}
}
}
imprimirArreglo(aleatorios);
}

Metodo QuickSort

//Metodo de QuickSort
public static void QuickSort(int numeros[], int izquierda,
int derecha){
//Se toma como pivote el primer valor
int pivote = numeros[izquierda];
//Se definen los dos lados y un auxiliar
int i = izquierda;
int j = derecha;
int aux;

while(i<j){
while (numeros[i] <= pivote && i < j)
i++;
while (numeros[j] > pivote)
j--;
if (i<j) {
aux = numeros[i];
numeros[i]= numeros[j];
numeros[j]=aux;
}
}
numeros[izquierda] = numeros[j];

-5-
 numeros[j] = pivote;
if (izquierda < j-1)
QuickSort(numeros,izquierda,j-1);
if (j+1 < derecha)
QuickSort(numeros,j+1,derecha);
}

public static void InvocarQuickSort(){

QuickSort(aleatorios, 0, aleatorios.length -1);
imprimirArreglo(aleatorios);
}
Metodo Shellsort
//Metodo ShellSort
public static void ShellSort(int arreglo[]){
int salto, aux, i;
boolean cambios;

for (salto = arreglo.length / 2; salto != 0; salto /= 2)

{
cambios = true;
while (cambios) { //Mientras se
intercambie algún elemento
cambios = false;
for (i = salto; i < arreglo.length; i++){
//Se da una pasada
if (arreglo[i - salto] > arreglo[i]) {
//Si están desordenados
aux = arreglo[i];
// Se reordenan
arreglo[i] = arreglo[i - salto];
arreglo[i - salto] = aux;
cambios = true; //Y se
marca como cambio.
}
}
}
}
}

public static void InvocarShellSort(){

ShellSort(aleatorios);
imprimirArreglo(aleatorios);
}
//Metodo de Radix
public static void Radix(int[] arreglo){
if(arreglo.length == 0)
return;

-6-
 int[][] m = new int[arreglo.length][2];
int[] q = new int[0x100];
int i,j,k,l,f = 0;
for(k=0;k<4;k++){
for(i=0;i<(m.length-1);i++)
m[i][1] = i+1;
m[i][1] = -1;
for(i=0;i<q.length;i++)
q[i] = -1;
for(f=i=0;i<arreglo.length;i++){
j = ((0xFF<<(k<<3))&arreglo[i])>>(k<<3);
if(q[j] == -1)
l = q[j] = f;
else{
l = q[j];
while(m[l][1] != -1)
l = m[l][1];
m[l][1] = f;
l = m[l][1];
}
f = m[f][1];
m[l][0] = arreglo[i];
m[l][1] = -1;
}
for(l=q[i=j=0];i<0x100;i++)
for(l=q[i];l!=-1;l=m[l][1])
arreglo[j++] = m[l][0];
}
Metodo Radix

public static void InvocarRadix(){

Radix(aleatorios);
imprimirArreglo(aleatorios);
}
}

Codigo completo

package P_1;

public class Metodos {

static int [] aleatorios = new int [999];

-7-
 public static void InvocarAleatorio(){
int indice = 0;
//Bucle que se ejecuta hasta que se haya llenado
while(indice < 999) {
int propuesto = (int)(Math.random()*5000);
boolean repetido = false;
//Bucle que se ejecuta siempre que el número no esté
repetido
while(!repetido) {
//Bucle que recorre el arreglo comparando el
número propuesto con cada uno de los elementos del arreglo
for(int i=0; i<indice; i++) {
if(propuesto == aleatorios[i]) {
repetido = true;
break;
}
}
if(!repetido) {
aleatorios[indice] = propuesto;
indice++;
}
}
}
imprimirArreglo(aleatorios);
}

public static void imprimirArreglo(int arreglo[]){

for(int i = 0; i < arreglo.length; i++){
System.out.println(arreglo[i]);
}
}

//Metodo Burbuja
public static void Burbuja(){
int temporal;
int tamaño = aleatorios.length;
for (int i = 1; i < tamaño; i++) {
for (int k = tamaño - 1; k >= i; k--) {
if(aleatorios[k] < aleatorios[k-1]){
temporal = aleatorios[k];
aleatorios[k] = aleatorios[k-1];
aleatorios[k-1]= temporal;
}
}
}
imprimirArreglo(aleatorios);
}

-8-
//Metodo de QuickSort
public static void QuickSort(int numeros[], int izquierda,
int derecha){
//Se toma como pivote el primer valor
int pivote = numeros[izquierda];
//Se definen los dos lados y un auxiliar
int i = izquierda;
int j = derecha;
int aux;

while(i<j){
while (numeros[i] <= pivote && i < j)
i++;
while (numeros[j] > pivote)
j--;
if (i<j) {
aux = numeros[i];
numeros[i]= numeros[j];
numeros[j]=aux;
}
}
numeros[izquierda] = numeros[j];
numeros[j] = pivote;
if (izquierda < j-1)
QuickSort(numeros,izquierda,j-1);
if (j+1 < derecha)
QuickSort(numeros,j+1,derecha);
}

public static void InvocarQuickSort(){

QuickSort(aleatorios, 0, aleatorios.length -1);
imprimirArreglo(aleatorios);
}

//Metodo ShellSort
public static void ShellSort(int arreglo[]){
int salto, aux, i;
boolean cambios;

for (salto = arreglo.length / 2; salto != 0; salto /= 2)

{
cambios = true;
while (cambios) { //Mientras se
intercambie algún elemento
cambios = false;

-9-
 for (i = salto; i < arreglo.length; i++){
//Se da una pasada
if (arreglo[i - salto] > arreglo[i]) {
//Si están desordenados
aux = arreglo[i];
// Se reordenan
arreglo[i] = arreglo[i - salto];
arreglo[i - salto] = aux;
cambios = true; //Y se
marca como cambio.
}
}
}
}
}

public static void InvocarShellSort(){

ShellSort(aleatorios);
imprimirArreglo(aleatorios);
}
//Metodo de Radix
public static void Radix(int[] arreglo){
if(arreglo.length == 0)
return;
int[][] m = new int[arreglo.length][2];
int[] q = new int[0x100];
int i,j,k,l,f = 0;
for(k=0;k<4;k++){
for(i=0;i<(m.length-1);i++)
m[i][1] = i+1;
m[i][1] = -1;
for(i=0;i<q.length;i++)
q[i] = -1;
for(f=i=0;i<arreglo.length;i++){
j = ((0xFF<<(k<<3))&arreglo[i])>>(k<<3);
if(q[j] == -1)
l = q[j] = f;
else{
l = q[j];
while(m[l][1] != -1)
l = m[l][1];
m[l][1] = f;
l = m[l][1];
}
f = m[f][1];
m[l][0] = arreglo[i];
m[l][1] = -1;

- 10 -
 }
for(l=q[i=j=0];i<0x100;i++)
for(l=q[i];l!=-1;l=m[l][1])
arreglo[j++] = m[l][0];
}
}

public static void InvocarRadix(){

Radix(aleatorios);
imprimirArreglo(aleatorios);
}
}
package P_1;

import java.util.Scanner;

public class PruebaP_1 {

public static void main(String[] args) {

int eleccion = 0;

do{
Scanner entdatos = new Scanner(System.in);
System.out.println("1. Carga de Datos\n"
+"2. Algoritmo de ordenamiento Burbuja\n"
+"3. Algoritmo de ordenamiento QuickSort\n"
+"4. Algoritmo de ordenamiento ShellSort\n"
+"5. Algoritmo de ordenamiento Radix\n"
+"6. Salir\n"
+"Elija un opcion para continuar");
eleccion = entdatos.nextInt();

switch(eleccion){
case 1:
System.out.println("Arreglo aleatorio");
Metodos.InvocarAleatorio();
break;
case 2:
System.out.println("Arreglo con ordenamiento
Burbuja");
Metodos.Burbuja();
break;
case 3:
System.out.println("Arreglo con ordenamiento
QuickSort");
Metodos.InvocarQuickSort();

- 11 -
 break;
case 4:
System.out.println("Arreglo con ordenamiento
ShellSort");
Metodos.InvocarShellSort();
break;
case 5:
System.out.println("Arreglo con ordenamiento
Radix");
Metodos.InvocarRadix();
break;
case 6:
System.out.println("Programa Finalizado");
break;
default:
System.out.println("Eleccion invalida");
}
}while(eleccion!=6);
}

- 12 -
- 13 -
- 14 -
- 15 -
}
Conclusiones

Con esta práctica logramos conocer diferentes métodos de ordenamiento,

como son QuickSort, Shelsort, radix y burbuja, al realizar la práctica logre
implementar distintos algoritmos, gracias a esta práctica logramos reforzar lo
visto en clase, así mismo se probaron los diferentes algoritmos para saber si
funcionaban

- 16 -
Bibliografía
EcuRed. (s. f.-a). Algoritmo de Ordenamiento Shell - EcuRed. Recuperado 3 de

diciembre de 2021, de

https://www.ecured.cu/Algoritmo_de_Ordenamiento_Shell

EcuRed. (s. f.-b). Ordenamiento Radix - EcuRed. Recuperado 3 de diciembre

de 2021, de https://www.ecured.cu/Ordenamiento_Radix

EcuRed. (s. f.-c). QuickSort - EcuRed. Recuperado 3 de diciembre de 2021, de

https://www.ecured.cu/QuickSort

Joyanes, L. A., & Martínez, I. Z. (2008). Estructura de datos en Java (1.a ed.).
McGraw-Hill Education.

- 17 -