UNIVERSIDAD ISRAEL

CIENCIAS DE LA INGENIERÍA

CARRERA DE INFORMÁTICA

SISTEMATIZACIÓN DE CONTENIDOS BÁSICOS DE LA CARRERA

SEMESTRE 2022 A

LABORATORIO S3

TEMA: Métodos de Ordenamiento

PROFESOR: Mg. Luis Fernando Aguas Bucheli

QUITO, 2022
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

1. TEMA: Métodos de Ordenamiento

2. OBJETIVOS:

• Adquirir los conceptos básicos relacionados con Métodos de Ordenamiento

• Reconocer las características de Métodos de Ordenamiento

3. OBJETIVOS DE DESARROLLO SOSTENIBLE:

Indicador 4.3: De aquí a 2030, asegurar el acceso igualitario de todos los hombres y las mujeres
a una formación técnica, profesional y superior de calidad, incluida la enseñanza universitaria

4. INTRODUCCION:

Métodos de Ordenamiento

Ordenamiento

Es la operación de arreglar los registros de una tabla en algún orden secuencial de acuerdo a un
criterio de ordenamiento. El ordenamiento se efectúa con base en el valor de algún campo en
un registro. El propósito principal de un ordenamiento es el de facilitar las búsquedas de los
miembros del conjunto ordenado.

El ordenar un grupo de datos significa mover los datos o sus referencias para que queden en una
secuencia tal que represente un orden, el cual puede ser numérico, alfabético o incluso
alfanumérico, ascendente o descendente.

✓ Métodos de Ordenamiento Elementales:

1. Inserción
2. Selección
3. Burbujeo

✓ Métodos de Ordenamiento no Elementales:

1
Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

1. Shell
2. Quick Sort
3. Fusión

❖ Tipos de Ordenamiento:
• Ordenamiento Interno → Ordenamiento de datos en Memoria Principal. (La
lectura y grabación se hacen en registros)
• Ordenamiento Externo → Ordenamiento de datos en Disco.

❖ Tipos de Entrada de Datos:

a. Entrada Ordenada = MEJOR CASO
b. Entrada Orden Inverso = PEOR CASO
c. Entrada Desordenada = CASO AL AZAR

❖ Tipos de Algoritmo
• Algoritmo Sensible: Modifica su tiempo de ejecución según el tipo de entrada.
• Algoritmo No Sensible: Su tiempo de ejecución es independiente al tipo de
entrada.
• Algoritmo Estable: Aquellos que teniendo clave repetida, mantiene su posición
inicial igual a la final.
• Algoritmo No Estable: Aquello que no respetan la posición inicial igual que la
final teniendo claves repetidas

✓ Métodos Elementales:

1. ORDENAMIENTO POR SELECCIÓN

DESCRIPCIÓN.

Ø Buscas el elemento más pequeño de la lista.

Ø Lo intercambias con el elemento ubicado en la primera posición de la lista.
Ø Buscas el segundo elemento más pequeño de la lista.
Ø Lo intercambias con el elemento que ocupa la segunda posición en la lista.
Ø Repites este proceso hasta que hayas ordenado toda la lista.

ANÁLISIS DEL ALGORITMO.

Ø Requerimientos de Memoria: Al igual que el ordenamiento burbuja, este algoritmo sólo

necesita una variable adicional para realizar los intercambios.
Ø Tiempo de Ejecución: El ciclo externo se ejecuta n veces para una lista de n elementos.
Cada búsqueda requiere comparar todos los elementos no clasificados.
2

Ventajas:
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

1. Fácil implementación.
2. No requiere memoria adicional.
3. Rendimiento constante: poca diferencia entre el peor y el mejor caso.

Desventajas:

1. Lento.
2. Realiza numerosas comparaciones.

2. ORDENAMIENTO POR INSERCIÓN DIRECTA

DESCRIPCIÓN.

El algoritmo de ordenación por el método de inserción directa es un algoritmo

relativamente sencillo y se comporta razonablemente bien en gran cantidad de situaciones.

Completa la tripleta de los algoritmos de ordenación más básicos y de orden de

complejidad cuadrático, junto con SelectionSort y BubbleSort.

Se basa en intentar construir una lista ordenada en el interior del array a ordenar.

De estos tres algoritmos es el que mejor resultado da a efectos prácticos. Realiza una
cantidad de comparaciones bastante equilibrada con respecto a los intercambios, y tiene un par
de características que lo hacen aventajar a los otros dos en la mayor parte de las situaciones.

Este algoritmo se basa en hacer comparaciones, así que para que realice su trabajo de
ordenación son imprescindibles dos cosas: un array o estructura similar de elementos
comparables y un criterio claro de comparación, tal que dados dos elementos nos diga si están
en orden o no.

En cada iteración del ciclo externo los elementos 0 a i forman una lista ordenada.

ANÁLISIS DEL ALGORITMO.

Ø Estabilidad: Este algoritmo nunca intercambia registros con claves iguales. Por lo tanto
es estable.
Ø Requerimientos de Memoria: Una variable adicional para realizar los intercambios.
Ø Tiempo de Ejecución: Para una lista de n elementos el ciclo externo se ejecuta n1
veces. El ciclo interno se ejecuta como máximo una vez en la primera iteración, 2 veces
en la segunda, 3 veces en la tercera, etc.

Ventajas:

1. Fácil implementación.
2. Requerimientos mínimos de memoria.
3
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Desventajas:

1. Lento.
2. Realiza numerosas comparaciones.

Este también es un algoritmo lento, pero puede ser de utilidad para listas que están ordenadas
o semiordenadas, porque en ese caso realiza muy pocos desplazamientos.

3. METODO DE LA BURBUJA

DESCRIPCIÓN

La idea básica del ordenamiento de la burbuja es recorrer el conjunto de elementos en

forma secuencial varias veces. Cada paso compara un elemento del conjunto con su sucesor (x[i]
con x[i+i]), e intercambia los dos elementos si no están en el orden adecuado.

El algoritmo utiliza una bandera que cambia cuando se realiza algún intercambio de
valores, y permanece intacta cuando no se intercambia ningún valor, pudiendo así detener el
ciclo y terminar el proceso de ordenamiento cuando no se realicen intercambios, lo que indica
que este ya está ordenado.

Este algoritmo es de fácil comprensión y programación pero es poco eficiente puesto

que existen n-1 pasos y n-i comprobaciones en cada paso, aunque es mejor que el algoritmo de
ordenamiento por intercambio.

En el peor de los casos cuando los elementos están en el orden inverso, el número
máximo de recorridos es n-1 y el número de intercambios o comparaciones está dado por (n-1)
* (n-1) = n² - 2n + 1.En el mejor de los casos cuando los elementos están en su orden, el número
de recorridos es mínimo 1 y el ciclo de comparaciones es n-1.

La complejidad del algoritmo de la burbuja es O(n) en el mejor de los casos y O(n²) en el

peor de los casos, siendo su complejidad total O(n²).

✓ Métodos No Elementales:

4. ORDENAMIENTO POR EL MÉTODO DE SHELL

DESCRIPCIÓN

El método Shell es una versión mejorada del método de inserción directa. Este
método también se conoce con el nombre de inserción con incrementos crecientes. En el
método de ordenación por inserción directa cada elemento se compara para su ubicación
correcta en el arreglo, con los elementos que se encuentran en la parte izquierda del mismo.
4
Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Si el elemento a insertar es más pequeño que el grupo de elementos que se encuentran a

su izquierda, es necesario efectuar entonces varias comparaciones antes de su ubicación.

Shell propone que las comparaciones entre elementos se efectúen con saltos de
mayor tamaño pero con incrementos decrecientes, así, los elementos quedarán ordenados
en el arreglo más rápidamente.

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

cuenta dos observaciones:

1. El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".

2. El ordenamiento por inserción es ineficiente, en general, porque mueve los valores

sólo una posición cada vez.

El algoritmo Shell sort mejora el ordenamiento por inserción comparando

elementos separados por un espacio de varias posiciones. Esto permite que un elemento
haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos
se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es
un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los
datos del vector están casi ordenados.

5. ORDENAMIENTO QUICK SORT

DESCRIPCIÓN

El ordenamiento por partición (Quick Sort) se puede definir en una forma más
conveniente como un procedimiento recursivo.

Tiene aparentemente la propiedad de trabajar mejor para elementos de entrada

desordenados completamente, que para elementos semiordenados. Esta situación es
precisamente la opuesta al ordenamiento de burbuja.

Este tipo de algoritmos se basa en la técnica "divide y vencerás", o sea es más rápido
y fácil ordenar dos arreglos o listas de datos pequeños, que un arreglo o lista grande.

Normalmente al inicio de la ordenación se escoge un elemento aproximadamente

en la mitad del arreglo, así al empezar a ordenar, se debe llegar a que el arreglo este
ordenado respecto al punto de división o la mitad del arreglo.

Se podrá garantizar que los elementos a la izquierda de la mitad son los menores y
los elementos a la derecha son los mayores.

Los siguientes pasos son llamados recursivos con el propósito de efectuar la

ordenación por partición al arreglo izquierdo y al arreglo derecho, que se obtienen de la
primera fase. El tamaño de esos arreglos en promedio se reduce a la mitad.

Así se continúa hasta que el tamaño de los arreglos a ordenar es 1, es decir, todos
5

los elementos ya están ordenados.

 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

En promedio para todos los elementos de entrada de tamaño n, el método hace O(n
log n) comparaciones, el cual es relativamente eficiente.

6. ORDENAMIENTO POR MEZCLA

DESCRIPCIÓN

Mediante el enfoque de Dividir y conquistar, este algoritmo divide el arreglo inicial en

dos arreglos donde cada uno contiene la mitad de los datos (partes iguales mas o menos uno),
y se ordenan mediante sucesivos llamados recursivos para luego fusionar los resultados en el
arreglo inicial.

Este algoritmo se basa en una función que permite mezclar dos vectores ordenados,
produciendo como resultado un tercer vector ordenado que contiene los elementos de los dos
vectores iniciales, el cual tiene una complejidad de O(n) para mezclar dos arreglos, donde n es
la suma de los tamaños de los dos arreglos.

El algoritmo principal que divide el arreglo, realiza O (log2 n) particiones y como llama a
la función que mezcla los dos arreglos y que tiene una complejidad de O(n), entonces la
complejidad total del algoritmo será de O(n log2 n).

COMPLEJIDAD

Cada algoritmo de ordenamiento por definición tiene operaciones y cálculos mínimos y máximos
que realiza (complejidad), a continuación una tabla que indica la cantidad de cálculos que
corresponden a cada método de ordenamiento:

Algoritmo Operaciones máximas

Burbuja Ω (n²)

Inserción Ω (n²/4)

Selección Ω (n²)

Shell Ω (n log²n)

Merge Ω (n logn)

Quick Ω (n²) en peor de los casos y Ω(n logn) en el

promedio de los casos.

5. DESARROLLO:
6

Ingresamos al visual studio:

 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Seleccionamos Crear un proyecto

En buscar plantillas colocamos Windows Forms

 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Seleccionamos la que tenga C# y damos clic en siguiente

Colocamos un nombre en la parte nombre proyecto, configuramos la ubicación

 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Teniendo:

Teniendo:
9
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Colocamos:

label combobox button

Damos clic en el combo box, en la propiedad:

Agregando:
10
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Damos clic en aceptar

Damos doble clic en el botón

Colocamos este código:

static void Metodo_Burbuja(int[] arreglo)

{
//Registra el tiempo al start de la Invocada del metodo
DateTime start = DateTime.Now;

int i;//Contador
int j;//Variable auxiliar
int aux1;//Variable auxiliar
int cont = 0;
for (i = 0; i < (arreglo.Length - 1); i++)
for (j = i + 1; j < arreglo.Length; j++)
if (arreglo[i] > arreglo[j])
{
aux1 = arreglo[i];
arreglo[i] = arreglo[j];
arreglo[j] = aux1;
cont++;
}

//Registra el tiempo al fin de la Invocada del metodo

11

DateTime finish = DateTime.Now;

TimeSpan elapsed = finish - start;
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

double totalSeconds = elapsed.TotalSeconds;

int seconds = elapsed.Seconds;

//Visualiza las iteraciones

MessageBox.Show("Iteracciones Totales:" + cont);

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed time): " +
totalSeconds + " seconds");

//Método Heapsort
static void Metodo_Heapsort(int[] arreglo)
{
//Registra el tiempo al start de la Invocada del metodo
DateTime start = DateTime.Now;

int N, T;
int k;
int cont1 = 0, cont2 = 0;
N = arreglo.Length;
for (k = N / 2; k > 0; k--)
{
arreglo = Empujar(arreglo, k, N);
cont1++;
}
do
{
T = arreglo[0];
arreglo[0] = arreglo[N - 1];
arreglo[N - 1] = T;
N--;
arreglo = Empujar(arreglo, 1, N);
cont2++;
} while (N > 1);

//Registra el tiempo al fin de la Invocada del metodo

DateTime finish = DateTime.Now;
TimeSpan elapsed = finish - start;
double totalSeconds = elapsed.TotalSeconds;
int seconds = elapsed.Seconds;

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales:" + (cont1 + cont2));
12

//Visualiza el tiempo de ordenamiento

 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

MessageBox.Show("Tiempo de Respuesta (Elapsed time): " +

totalSeconds + " seconds");

static int[] Empujar(int[] arreglo_a, int k, int N)

{
int j;
int T = arreglo_a[k - 1];
while (k <= N / 2)
{
j = k + k;
if ((j < N) && (arreglo_a[j - 1] < arreglo_a[j]))
j++;
if (T >= arreglo_a[j - 1])
break;
else
{
arreglo_a[k - 1] = arreglo_a[j - 1];
k = j;
}
}
arreglo_a[k - 1] = T;
return arreglo_a;
}
//Método Shellsort
static void shell(int[] arreglo)
{
DateTime start = DateTime.Now;
int n = arreglo.Length;//recoje tamaño del arr a ordenar
int gap = n / 2;//variable a inicializar gap
int cont = 0;
while (gap >= 1)
{
for (int i = gap; i < n; i++)
{
int temp = arreglo[i];
int j = i;
if (j >= gap)
if (temp < arreglo[j - gap])
{
arreglo[j] = arreglo[j - gap];
cont++;
j -= gap;
}
13

arreglo[j] = temp;
cont++;
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

}
gap /= 2;
}

//Registra el tiempo al fin de la Invocada del metodo

DateTime finish = DateTime.Now;
TimeSpan elapsed = finish - start;
double totalSeconds = elapsed.TotalSeconds;
int seconds = elapsed.Seconds;

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales:" + cont);

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed time): " +
totalSeconds + " seconds");

//Mátodo Insercion Binaria

public static void Metodo_Inserción_Binaria(int[] arreglo_a)
{
DateTime start = DateTime.Now;
int i, j, aux1, cont = 0;
for (i = 1; i < arreglo_a.Length; i++)
{
aux1 = arreglo_a[i];
cont++;
j = i;
//Retorna a la derecha hasta encontrar la posicion deseada sin
salirse del start del arreglo
while ((j > 0) && (aux1 < arreglo_a[j - 1]))
{
arreglo_a[j] = arreglo_a[j - 1];
cont++;
j--;
}
arreglo_a[j] = aux1;
cont++;
}
//Registra el tiempo al fin de la Invocada del metodo
DateTime finish = DateTime.Now;
TimeSpan elapsed = finish - start;
double totalSeconds = elapsed.TotalSeconds;
int seconds = elapsed.Seconds;
14

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales: " + cont);
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed time): " +
totalSeconds + " seconds");

//Método-Insercion directa
public static void Metodo_Seleccion_Directa(int[] arreglo)
{
DateTime start = DateTime.Now;
int i, j, k, cont = 0; //Contadores
int aux1; //Variable
for (i = 0; i < arreglo.Length; i++)
{
k = i;
aux1 = arreglo[i];
for (j = i + 1; j < arreglo.Length; j++)
{
if (arreglo[j] < aux1)
{
k = j;
aux1 = arreglo[j]; //Aqui se hace la selccion
}

}
arreglo[k] = arreglo[i];
arreglo[i] = aux1;
cont++;
}

//Registra el tiempo al fin de la Invocada del metodo

DateTime finish = DateTime.Now;
TimeSpan elapsed = finish - start;
double totalSeconds = elapsed.TotalSeconds;
int seconds = elapsed.Seconds;

//Visualiza las iteraciones

MessageBox.Show("\nIteraciones Totales: " + cont);

//Visualiza el tiempo de ordenamiento

MessageBox.Show("\nTiempo de Respuesta (Elapsed time): " +
totalSeconds + " seconds");
15

}
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

//Método RadixSort
static void Metodo_Radixsort(int[] arreglo, int d)
{
DateTime start = DateTime.Now;
int[] A = new int[arreglo.Length];
int[] B = new int[arreglo.Length];

int n = 0, pos = 0, cont = 1, flag = 1, contador = 0;

do
{
pos = 0;
for (int i = 0; i < arreglo.Length; i++)
{
A[i] = arreglo[i] / flag;
}

for (int i = 0; i < arreglo.Length; i++)

A[i] = (A[i] % 10);

for (n = 0; n < 10; n++)

for (int i = 0; i < A.Length; i++)
if (A[i] == n)
{
B[pos] = arreglo[i];
pos++;
contador++;
}
cont++;
flag = flag * 10;
for (int i = 0; i < B.Length; i++)
arreglo[i] = B[i];
} while (d >= cont);

//Registra el tiempo al fin de la Invocada del metodo

DateTime finish = DateTime.Now;
TimeSpan elapsed = finish - start;
double totalSeconds = elapsed.TotalSeconds;
int seconds = elapsed.Seconds;

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales:" + contador);

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed time): " +
totalSeconds + " seconds");
16

}
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

//Método-Tournament
static void Metodo_Tornament(int[] arre)
{
DateTime start = DateTime.Now;
int men = 5000, cont = 0, pos = 0, num = 0;
int[] narr = new int[arre.Length];
int contador = 0;
//contador++;
do
{
if (cont == 0)
{
for (int i = 0; i < arre.Length; i += 2)
{
if (arre[i] < arre[i + 1] && arre[i] < men)
{
men = arre[i];
pos = i;
contador++;
}
if (arre[i + 1] < arre[i] && arre[i + 1] < men)
{
men = arre[i + 1];
pos = i + 1;
contador++;
}
}
num = men - 1;
}
else
{
for (int i = 0; i < arre.Length; i += 2)
{
if (arre[i] == num || arre[i + 1] == num)
{
if (arre[i] != arre[i + 1])
{
if (arre[i] == num)
if (arre[i + 1] < men)
{
men = arre[i +
1];
pos = i + 1;
contador++;
}
17

if (arre[i + 1] == num)
if (arre[i] < men)
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

{
men = arre[i];
pos = i;
contador++;
}
}
}
else
{
if (arre[i] < arre[i + 1] && arre[i] < men
&& arre[i] != num)
{
men = arre[i];
pos = i;
contador++;
}
if (arre[i + 1] < arre[i] && arre[i + 1] <
men && arre[i + 1] != num)
{
men = arre[i + 1];
pos = i + 1;
contador++;
}
}
}
}
narr[cont] = men;
cont++;
arre[pos] = num;
men = 5000;
} while (cont < arre.Length);

//Registra el tiempo al fin de la Invocada del metodo

DateTime finish = DateTime.Now;
TimeSpan elapsed = finish - start;
double totalSeconds = elapsed.TotalSeconds;
int seconds = elapsed.Seconds;

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales: " + contador);

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed time): " +
totalSeconds + " seconds");
18

}
Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

//Método-Mergesort
static double[] Metodo_MergeSort(double[] arreglo, int Menor, int Mayor)
{
DateTime start = DateTime.Now;
int Longitud; //Longitud del sub-arreglo
double[] Trabajo; //Vector de trabajo para las divisiones
int Pivote; //Posición de corte
int m1, m2; //Posición inicial y final del sub-arreglo
int i; //Contador
double[] arreglo1 = new double[arreglo.Length + 2];
int cont = 0;

if (Menor == Mayor)
return arreglo;

//Se calculan valores iniciales

Longitud = Mayor - Menor + 1;
Pivote = (Menor + Mayor) / 2;

//Se realiza la Invocada a la recursiva de ordenación y división

Metodo_MergeSort(arreglo, Menor, Pivote);
Metodo_MergeSort(arreglo, Pivote + 1, Mayor);

//Se realiza la fusión

Trabajo = new double[Longitud];
for (i = 0; i < Longitud; i++)
Trabajo[i] = arreglo[Menor + i];
m1 = 0;
m2 = Pivote - Menor + 1;

for (i = 0; i < Longitud; i++)

{
if (m2 <= Mayor - Menor)
{
if (m1 <= Pivote - Menor)
{
cont++;
if (Trabajo[m1] > Trabajo[m2])
{
arreglo[i + Menor] = Trabajo[m2++];
cont++;
}

else
{
arreglo[i + Menor] = Trabajo[m1++];
19

cont++;
}
Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

else
{
arreglo[i + Menor] = Trabajo[m2++];
cont++;
}
}

else
{
arreglo[i + Menor] = Trabajo[m1++];
cont++;
}

DateTime finish = DateTime.Now;

TimeSpan elapsed = finish - start;
double totalSeconds = elapsed.TotalSeconds;

for (int j = 0; j < arreglo.Length; j++)

arreglo1[j] = arreglo[j];

arreglo1[(arreglo1.Length) - 2] = cont;
arreglo1[(arreglo1.Length) - 1] = totalSeconds;
return arreglo1;
}

//Método QuickSort
public static void Metodo_QuickSort(ref int[] arreglo, int Primero, int ultimo)
{
int aux1;//variable para valores temporales
int inferior;//posicion menor
int superior;//posicion mayor
int separador;//separacion
inferior = Primero;
superior = ultimo;
separador = arreglo[(Primero + ultimo) / 2];
do
{
while (arreglo[inferior] < separador)
inferior += 1;
while (arreglo[superior] > separador)
superior -= 1;
if (inferior <= superior)
20

{
aux1 = arreglo[inferior];
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

arreglo[inferior] = arreglo[superior];
//incremento cont++;
arreglo[superior] = aux1;
//incremento cont++;
inferior += 1;
superior -= 1;
}

} while (inferior <= superior);

if (Primero < superior)

{
Metodo_QuickSort(ref arreglo, Primero, superior);
}
if (inferior < ultimo)
{
Metodo_QuickSort(ref arreglo, inferior, ultimo);
}
}

Teniendo:

Damos doble clic en el botón y en:

21
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Colocamos el siguiente código:

int Param;

Param = comboBox1.SelectedIndex;

switch (Param)
{
case 0://Algoritmo - Insercion Directa
//Construye numeros randomicos para la matriz
int[] Arregloid = new int[1000];
Random rid = new Random();
for (int i = 0; i < Arregloid.Length; i++)
Arregloid[i] = (int)(rid.NextDouble() * 255);
//Invoca a la funcion Insercion Directa

MessageBox.Show("En la matriz de: " +

Arregloid.Length + " datos");
Metodo_Seleccion_Directa(Arregloid);

//Construye numeros randomicos para la matriz

int[] Arregloid1 = new int[10000];
Random rid1 = new Random();
for (int i = 0; i < Arregloid1.Length; i++)
Arregloid1[i] = (int)(rid1.NextDouble() * 255);
//Invoca a la funcion Insercion Directa

MessageBox.Show("En la matriz de: " +

Arregloid1.Length + " datos");
Metodo_Seleccion_Directa(Arregloid1);

//Construye numeros randomicos para la matriz

int[] Arregloid2 = new int[100000];
Random rid2 = new Random();
for (int i = 0; i < Arregloid2.Length; i++)
Arregloid2[i] = (int)(rid2.NextDouble() * 255);

//Invoca a la funcion Insercion Directa

22
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

MessageBox.Show("En la matriz de: " +

Arregloid2.Length + " datos");
Metodo_Seleccion_Directa(Arregloid2);

break;

case 1://Algoritmo-ShellSort
//Construye numeros randomicos para la matriz
int[] Arreglosh = new int[100000];
Random rsh = new Random();
for (int i = 0; i < Arreglosh.Length; i++)
Arreglosh[i] = (int)(rsh.NextDouble() * 255);
//Invoca a la funcion ordenar Shell

MessageBox.Show("En la matriz de: " +

Arreglosh.Length + " datos");
shell(Arreglosh);

//Construye numeros randomicos para la matriz

int[] Arreglosh1 = new int[1000000];
Random rsh1 = new Random();
for (int i = 0; i < Arreglosh1.Length; i++)
Arreglosh1[i] = (int)(rsh1.NextDouble() * 255);
//Invoca a la funcion ordenar Shell

MessageBox.Show("En la matriz de: " +

Arreglosh1.Length + " datos");
shell(Arreglosh1);

//Construye numeros randomicos para la matriz

int[] Arreglosh2 = new int[10000000];
Random rsh2 = new Random();
for (int i = 0; i < Arreglosh2.Length; i++)
Arreglosh2[i] = (int)(rsh2.NextDouble() * 255);
//Invoca a la funcion ordenar Shell

MessageBox.Show("En la matriz de: " +

Arreglosh2.Length + " datos");
shell(Arreglosh2);

break;

case 2://Algoritmo-Insercion Binaria

//Construye numeros randomicos para la matriz
23

int[] Arregloib = new int[1000];

Random rib = new Random();
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

for (int i = 0; i < Arregloib.Length; i++)

Arregloib[i] = (int)(rib.NextDouble() * 255);
//Invoca a la funcion Insercion Binaria

MessageBox.Show("En la matriz de: " +

Arregloib.Length + " datos");
Metodo_Inserción_Binaria(Arregloib);

//Construye numeros randomicos para la matriz

int[] Arregloib1 = new int[10000];
Random rib1 = new Random();
for (int i = 0; i < Arregloib1.Length; i++)
Arregloib1[i] = (int)(rib1.NextDouble() * 255);
//Invoca a la funcion Insercion Binaria

MessageBox.Show("En la matriz de: " +

Arregloib1.Length + " datos");
Metodo_Inserción_Binaria(Arregloib1);

//Construye numeros randomicos para la matriz

int[] Arregloib2 = new int[100000];
Random rib2 = new Random();
for (int i = 0; i < Arregloib2.Length; i++)
Arregloib2[i] = (int)(rib2.NextDouble() * 255);
//Invoca a la funcion Insercion Binaria

MessageBox.Show("En la matriz de: " +

Arregloib2.Length + " datos");
Metodo_Inserción_Binaria(Arregloib2);
Console.ReadLine();
break;

case 3://Algoritmo-Burbuja
//Construye numeros randomicos para la matriz
int[] Arreglo = new int[1000];
Random r = new Random();
for (int i = 0; i < Arreglo.Length; i++)
Arreglo[i] = (int)(r.NextDouble() * 255);
//Invoca a la funcion Metodo de Ordenamiento por
Metodo_Burbuja

MessageBox.Show("En la matriz de: " + Arreglo.Length

+ " datos");
Metodo_Burbuja(Arreglo);
24
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

//Construye numeros randomicos para la matriz

int[] Arreglo1 = new int[10000];
Random r1 = new Random();
for (int i = 0; i < Arreglo1.Length; i++)
Arreglo1[i] = (int)(r1.NextDouble() * 255);
//Invoca a la funcion Metodo de Ordenamiento por
Metodo_Burbuja

MessageBox.Show("En la matriz de: " +

Arreglo1.Length + " datos");
Metodo_Burbuja(Arreglo1);

//Construye numeros randomicos para la matriz

int[] Arreglo2 = new int[100000];
Random r2 = new Random();
for (int i = 0; i < Arreglo2.Length; i++)
Arreglo2[i] = (int)(r2.NextDouble() * 255);
//Invoca a la funcion Metodo de Ordenamiento por
Metodo_Burbuja

MessageBox.Show("En la matriz de: " +

Arreglo2.Length + " datos");
Metodo_Burbuja(Arreglo2);

break;

case 4://Algoritmo-Quick sort

//Construye numeros randomicos para la matriz
int[] Arregloqs = new int[100000];
Random rqs = new Random();
for (int i = 0; i < Arregloqs.Length; i++)
Arregloqs[i] = (int)(rqs.NextDouble() * 255);
DateTime start = DateTime.Now;
//Invoca metodos quick sort
Metodo_QuickSort(ref Arregloqs, 0, Arregloqs.Length -
1);
DateTime finish = DateTime.Now;
Console.WriteLine("En la matriz de: " +
Arregloqs.Length + " datos");

//Registra el tiempo al fin de la Invocada del metodo

TimeSpan elapsed = finish - start;
double totalSeconds = elapsed.TotalSeconds;
int seconds = elapsed.Seconds;
25

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales: ");
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed
time): " + totalSeconds + " seconds");

//Construye numeros randomicos para la matriz

int[] Arregloqs1 = new int[1000000];
Random rqs1 = new Random();
for (int i = 0; i < Arregloqs1.Length; i++)
Arregloqs1[i] = (int)(rqs1.NextDouble() * 255);
DateTime start1 = DateTime.Now;

//Invoca metodos quick sort

Metodo_QuickSort(ref Arregloqs1, 0,
Arregloqs1.Length - 1);
DateTime finish1 = DateTime.Now;
MessageBox.Show("En la matriz de: " +
Arregloqs1.Length + " datos");

//Registra el tiempo al fin de la Invocada del metodo

TimeSpan elapsed1 = finish1 - start1;

double totalSeconds1 = elapsed1.TotalSeconds;
int seconds1 = elapsed1.Seconds;

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales: ");

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed
time): " + totalSeconds1 + " seconds");

//Construye numeros randomicos para la matriz

int[] Arregloqs2 = new int[10000000];
Random rqs2 = new Random();
for (int i = 0; i < Arregloqs2.Length; i++)
Arregloqs2[i] = (int)(rqs2.NextDouble() * 255);

DateTime start2 = DateTime.Now;

//Invoca metodos quick sort
Metodo_QuickSort(ref Arregloqs2, 0,
Arregloqs2.Length - 1);
DateTime finish2 = DateTime.Now;
MessageBox.Show("En la matriz de: " +
Arregloqs2.Length + " datos");
26

//Registra el tiempo al fin de la Invocada del metodo

 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

TimeSpan elapsed2 = finish2 - start2;

double totalSeconds2 = elapsed2.TotalSeconds;
int seconds2 = elapsed2.Seconds;

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales:");

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed
time): " + totalSeconds2 + " seconds");

break;

case 5://Algoritmo-Heapsort
//Construye numeros randomicos para la matriz
int[] QREX = new int[100000];
Random rhp = new Random();
for (int i = 0; i < QREX.Length; i++)
QREX[i] = (int)(rhp.NextDouble() * 255);

//Invoca a la funcion ordenar heapsort

MessageBox.Show("En la matriz de: " + QREX.Length +

" datos");
Metodo_Heapsort(QREX);
Console.ReadLine();

//Construye numeros randomicos para la matriz

int[] QREX1 = new int[1000000];
Random rhp1 = new Random();
for (int i = 0; i < QREX1.Length; i++)
QREX1[i] = (int)(rhp1.NextDouble() * 255);

//Invoca a la funcion ordenar heapsort

MessageBox.Show("En la matriz de: " + QREX1.Length

+ " datos");
Metodo_Heapsort(QREX1);

//Construye numeros randomicos para la matriz

int[] QREX2 = new int[10000000];
Random rhp2 = new Random();
for (int i = 0; i < QREX2.Length; i++)
QREX2[i] = (int)(rhp2.NextDouble() * 255);
27

//Invoca a la funcion ordenar heapsort

 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

MessageBox.Show("En la matriz de: " + QREX2.Length

+ " datos");
Metodo_Heapsort(QREX2);

break;

case 6://Algoritmo-Tornament
//Construye numeros randomicos para la matriz
int[] Arregloto = new int[1000];
Random rto = new Random();
for (int i = 0; i < Arregloto.Length; i++)
Arregloto[i] = (int)(rto.NextDouble() * 255);
//Invoca a la funcion Metodo_Tornament

MessageBox.Show("En la matriz de: " +

Arregloto.Length + " datos");
Metodo_Tornament(Arregloto);

//Construye numeros randomicos para la matriz

int[] Arregloto1 = new int[10000];
Random rto1 = new Random();
for (int i = 0; i < Arregloto1.Length; i++)
Arregloto1[i] = (int)(rto1.NextDouble() * 255);

//Invoca a la funcion Metodo_Tornament

MessageBox.Show("En la matriz de: " +

Arregloto1.Length + " datos");
Metodo_Tornament(Arregloto1);

//Construye numeros randomicos para la matriz

int[] Arregloto2 = new int[100000];
Random rto2 = new Random();
for (int i = 0; i < Arregloto2.Length; i++)
Arregloto2[i] = (int)(rto2.NextDouble() * 255);
//Invoca a la funcion Metodo_Tornament

MessageBox.Show("En la matriz de: " +

Arregloto2.Length + " datos");
Metodo_Tornament(Arregloto2);

break;
28

case 7://Algoritmo-MergeSort
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

//Construye numeros randomicos para la matriz

double[] arreglo_aa = new double[1000];
Random super = new Random();
for (int i = 0; i < arreglo_aa.Length; i++)
arreglo_aa[i] = (int)(super.NextDouble() * 255);
//Invoca a la funcion MergeSort
double[] arreglondra = new double[arreglo_aa.Length
+ 1];

MessageBox.Show("En la matriz de: " +

arreglo_aa.Length + " datos");
arreglondra = Metodo_MergeSort(arreglo_aa, 0,
arreglo_aa.Length - 1);

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales: " +
arreglondra[(arreglondra.Length) - 2]);

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed
time): " + arreglondra[(arreglondra.Length) - 1] + " seconds");

//Construye numeros randomicos para la matriz

double[] arreglo_aa1 = new double[10000];
Random super1 = new Random();
for (int i = 0; i < arreglo_aa1.Length; i++)
arreglo_aa1[i] = (int)(super1.NextDouble() *
255);
//Invoca a la funcion MergeSort
double[] arreglondra1 = new
double[arreglo_aa1.Length + 1];

MessageBox.Show("En la matriz de: " +

arreglo_aa1.Length + " datos");
arreglondra1 = Metodo_MergeSort(arreglo_aa1, 0,
arreglo_aa1.Length - 1);

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales: " +
arreglondra1[(arreglondra1.Length) - 2]);

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed
time): " + arreglondra1[(arreglondra1.Length) - 1] + " seconds");
29

//Construye numeros randomicos para la matriz

double[] arreglo_aa2 = new double[100000];
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

Random super2 = new Random();

for (int i = 0; i < arreglo_aa2.Length; i++)
arreglo_aa2[i] = (int)(super2.NextDouble() *
255);
//Invoca a la funcion MergeSort
double[] arreglondra2 = new
double[arreglo_aa2.Length + 1];

MessageBox.Show("En la matriz de: " +

arreglo_aa2.Length + " datos");
arreglondra = Metodo_MergeSort(arreglo_aa2, 0,
arreglo_aa2.Length - 1);

//Visualiza las iteraciones

MessageBox.Show("Iteraciones Totales: " +
arreglondra2[(arreglondra.Length) - 2]);

//Visualiza el tiempo de ordenamiento

MessageBox.Show("Tiempo de Respuesta (Elapsed
time): " + arreglondra2[(arreglondra2.Length) - 1] + " seconds");

break;

case 8://Algoritmo-Radixsort
//Construye numeros randomicos para la matriz
int[] arreglomega = new int[100000];
Random tqm = new Random();
for (int i = 0; i < arreglomega.Length; i++)
arreglomega[i] = (int)(tqm.NextDouble() * 255);
//Invoca a la funcion Radixsort

MessageBox.Show("En la matriz de: " +

arreglomega.Length + " datos");
Metodo_Radixsort(arreglomega, 3);

//Construye numeros randomicos para la matriz

int[] arreglomega1 = new int[1000000];
Random tqm1 = new Random();
for (int i = 0; i < arreglomega1.Length; i++)
arreglomega1[i] = (int)(tqm1.NextDouble() *
255);
//Invoca a la funcion Radixsort

MessageBox.Show("En la matriz de: " +

arreglomega1.Length + " datos");
30

Metodo_Radixsort(arreglomega1, 3);
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

//Construye numeros randomicos para la matriz

int[] arreglomega2 = new int[10000000];
Random tqm2 = new Random();
for (int i = 0; i < arreglomega2.Length; i++)
arreglomega2[i] = (int)(tqm2.NextDouble() *
255);
//Invoca a la funcion Radixsort

MessageBox.Show("En la matriz de: " +

arreglomega2.Length + " datos");
Metodo_Radixsort(arreglomega2, 3);

break;

} //switch

Teniendo:

Ejecutando:
31
 Universidad Israel
Ciencias de la Ingeniería
Carrera de Informática

6. BIBLIOGRAFIA:

32