ESCUELA SUPERIOR POLTÉCNICA DE CHIMBORAZO

UNIDAD DE ADMISIÒN Y NIVELACIÒN

CIENCIAS E INGENIERÍA

APELLIDOS Y NOMBRES Barragán Silva Homero Vinicio

ASIGNATURA Fundamentos de informática
TEMA: Métodos de ordenamiento
FECHA DE ENTREGA: 15 de enero de 2019 Especialidad Software
PARALELO: CI – 22 “C” No. DE
EJERCICIOS:
0
DOCENTE: Ing. Franklin Erazo

MÉTODOS DE ORDENAMIENTO

Insertion sort o método de inserción

Este método consiste en ordenar un elemento en un conjunto de elementos ya
ordenados. Es conocido como el método del jugador de cartas, ya que al igual que tomar
cartas boca abajo de una baraja y ordenarlas conforme las volteamos, en este método se
ordenará el elemento siguiente a los elementos anteriores ya ordenados.
Este método funciona de la siguiente manera:
- Tenemos como ejemplo un vector de 6 elementos desordenados:

4 3 2 1 8 5

- Tomamos como pivote el elemento de la posición 0 del vector y lo utilizaremos

como el primer elemento del conjunto que iremos ordenando:

4 3 2 1 8 5

- Ahora, comparamos el pivote con el elemento de la siguiente posición; este

elemento ahora es parte del conjunto, por lo tanto, hay que ordenarlo:

4 3 2 1 8 5

- En este caso, 3 es menor que cuatro; por lo tanto, intercambiamos los elementos:

3 4 2 1 8 5
- Una vez que los elementos del conjunto estén ordenados, tomamos el elemento
de la siguiente posición, lo hacemos parte del conjunto y lo ordenamos dentro de
este:

3 4 2 1 8 5

- Comparamos el nuevo elemento con los demás: 2 es menor a 4, por lo tanto,

realizamos el intercambio; 2 es menor a 3, también intercambiamos. Como ya no
hay más elementos por comparar entonces el conjunto ha quedado ordenado:

3 2 4 1 8 5

2 3 4 1 8 5
2 3 4 1 8 5

- Nuevamente tomamos el siguiente elemento del vector y lo comparamos con los

elementos del conjunto ordenado: 1 es menor a cuatro, intercambiamos; 1 es
menor a 3, intercambiamos; 1 es menos a 2, intercambiamos. Tenemos el conjunto
ordenado:

2 3 4 1 8 5

2 3 1 4 8 5

2 1 3 4 8 5

1 2 3 4 8 5

1 2 3 4 8 5

- En el siguiente caso, el nuevo elemento que tomamos para el conjunto ya está

ordenado, por ello, no se realiza ningún intercambio y procedemos a tomar el
siguiente elemento del vector:

1 2 3 4 8 5

1 2 3 4 8 5
 - Tomamos el último elemento, en este caso 5, y lo comparamos con el conjunto
ordenado: 5 es menor a 8, intercambiamos; 5 no es menor a 4, por lo tanto, no
intercambiamos.

1 2 3 4 8 5

1 2 3 4 5 8

- Finalmente, el conjunto ha tomado todos los elementos del vector y este ha

quedado ordenado:

1 2 3 4 5 8

En pseudocódigo el código de este método de ordenamiento es el siguiente:

Algoritmo insertion_sort
Imprimir "Ingrese el número de elementos del vector"
Leer n
Dimension vector[n]
Para v = 0 hasta (n-1) Con Paso 1
Imprimir "Vector[" v "]"
Leer vector(v)
FinPara
Para i = 0 hasta n-1 con paso 1
k = i + 1
Mientras k > 0 y k < n y vector(k) < vector(k-1) Hacer
aux = vector(k)
vector(k) = vector(k-1)
vector(k-1) = aux
k = k-1
FinMientras
FinPara
Para v = 0 hasta (n-1) Con Paso 1
Imprimir "Vector[" v "] = " vector(v)
 FinPara
FinAlgoritmo

Shell sort u ordenamiento Shell

Este método de ordenamiento es una generalización del método anterior (insertion sort),
que resulta eficiente cuando el vector está “casi ordenado” e ineficiente porque solo
mueve los valores una posición a la vez.
Se trata de una generalización del insertion sort porque primero ordena la mayor parte del
vector para finalmente ordenarlo con una inserción simple.
Shell sort funciona de la siguiente manera:

- Tenemos como ejemplo un vector de 6 elementos desordenados:

4 3 2 1 8 5

- Calculamos un intervalo igual a n div 2, donde n es el número de elementos del

vector.

Intervalo=n÷2=6÷2=3

Este intervalo será la distancia entre el primer número y el segundo número que
llamaremos p. El pivote (primer número) en este método siempre será el elemento
de la posición 0.

pivote p

4 3 2 1 8 5

Intervalo = 3
Como podemos ver, el pivote es el elemento de la posición 0, mientras que p es el
elemento que se encuentra en la posición igual a pivote + intervalo, es decir, el de
la posición 3.
Si el elemento de la posición pivote es mayor que p, entonces realizamos un
intercambio entre ambos elementos. En este caso, 4 es mayor a 1, por lo tanto,
realizamos el intercambio:

1 3 2 4 8 5
- Una vez que se haya comparado ambos números y se haya realizado o no un
intercambio, el pivote se mueve a la siguiente posición del vector, y, por lo tanto, p
también cambia. Ahora el pivote se encuentra en la posición 1 y p en la posición 4.
Comparamos: 3 es menor a 8, por lo tanto, no se realiza un intercambio:

1 3 2 4 8 5

- Nuevamente el pivote se mueve a la siguiente posición y p también cambia.

Comparamos: 2 es menor a 5, por lo tanto, no intercambiamos:

1 3 2 4 8 5

- Ahora, p ha tomado el valor de la última posición del vector por lo que no podrá
tomar más valores, por lo tanto, decimos que ha recorrido el vector.
En este primer recorrido se ha realizado intercambios, entonces volveremos a
recorrer con el mismo intervalo hasta que no se realice ningún intercambio en el
recorrido:

1 es menor a 3. No intercambiamos:

1 3 2 4 8 5

3 es menor a 8. No intercambiamos:

1 3 2 4 8 5

2 es menor a 5. No intercambiamos:

1 3 2 4 8 5

En este último recorrido no se realizó ningún intercambio, por lo tanto, podemos

proseguir.

- Una vez que no haya más elementos que intercambiar, el intervalo tomará el valor
de intervalo div 2 y volveremos a repetir el mismo proceso:

Intervalo=Intervalo÷2=3÷2=1
 Ahora, nuestro intervalo es igual a 1, por lo que p es igual a pivote + 1.
Nuevamente, el pivote empieza en la posición 0, pero p ahora es 1. Comparamos:

1 es menor a 3. No intercambiamos. El pivote y p se mueven una posición:

1 3 2 4 8 5

3 es mayor a 2. Intercambiamos. El pivote y p se mueven una posición:

1 2 3 4 8 5

3 es menor a 4. No intercambiamos. El pivote y p se mueven una posición:

1 2 3 4 8 5

4 es menor a 8. No intercambiamos. El pivote y p se mueven una posición:

1 2 3 4 8 5

8 es mayor a 5. Intercambiamos:

1 2 3 4 8 5

1 2 3 4 5 8

- El recorrido acaba porque p ya no puede tomar más posiciones. No es necesario

realizar otro recorrido pues el intervalo ya no puede hacerse más pequeño
(Intervalo > 0). El vector ha quedado ordenado.

1 2 3 4 5 8

El pseudocódigo de este algoritmo de ordenamiento es el siguiente:

Algoritmo shell_sort
Definir flag como Logico
flag = Verdadero
Imprimir "Ingrese el número de elementos del vector"
Leer n
 Dimension vector[n]
Para v = 0 hasta (n-1) Con Paso 1
Imprimir "Vector[" v "]"
Leer vector(v)
FinPara
shell = trunc(n/2)
Mientras shell > 0 hacer
Repetir
p = 0
q = shell
flag = Verdadero
Mientras q < n Hacer
Si vector(p) > vector(q)
aux = vector(q)
vector(q) = vector(p)
vector(p) = aux
flag = Falso
FinSi
p = p + 1
q = p + shell
FinMientras
Hasta que flag = Verdadero
shell = trunc(shell/2)
flag = Verdadero
FinMientras
Para v = 0 hasta (n-1) Con Paso 1
Imprimir "Vector[" v "] = " vector(v)
FinPara
FinAlgoritmo
Quick sort u ordenamiento rápido
Se trata de un método de ordenamiento basado en la técnica de divide y vencerás. Es el
algoritmo más rápido para ordenar los elementos de un vector y consiste en dividir el
vector, al principio en dos partes, de tal manera que a un lado queden los menores a un
elemento elegido como pivote y al otro los mayores del mismo; luego, se continúa
dividiendo cada parte por la mitad y ordenándolas de la misma forma.
Este método funciona de la siguiente manera:
- Tenemos como ejemplo un vector de 6 elementos desordenados:

4 3 2 1 8 5

- Elegimos nuestro pivote. En este caso, el elemento de la posición 3:

4 3 2 1 8 5

- El vector ha quedado divido por el pivote en dos partes. A la derecha colocaremos

los mayores y a la izquierda los menores, para ello, colocamos dos indicadores a
cada lado que nos servirán para compararlos con el pivote. En caso de que el
elemento marcado por el indicador no corresponda al lado en el que debe ser
ubicado (mayor o menor al pivote), entonces tendrá que ser cambiado, pero si
corresponde al lado correcto, entonces el indicador se mueve una posición con
dirección al pivote:

4 3 2 1 8 5

Empezamos a comparar:
4 no es menor a 1, por lo tanto, tiene que cambiarse.
5 es mayor a 1, por lo tanto, el indicador se mueve

4 3 2 1 8 5

8 es mayor a 1, por lo tanto, el indicador se mueve

4 3 2 1 8 5
 1 no es mayor a 1, por lo tanto, tiene que cambiarse.
Como el indicador de la izquierda, así como el de la derecha tienen que
cambiarse, entonces intercambiamos los elementos de cada uno.

1 3 2 4 8 5

- Ahora que los elementos menores al pivote están del lado izquierdo y los mayores
del lado derecho, elegimos dos nuevos pivotes para cada lado del primer pivote.
Vamos a ordenar primero el lado izquierdo del pivote:

1 3 2

Nuevamente debemos ordenar al lado derecho los mayores y al lado izquierdo los
menores del pivote, que en este caso es 3:

1 es menor a tres, por lo tanto, el indicador se mueve.

1 3 2

2 no es mayor a 3, por lo tanto, tiene que cambiarse.

3 no es menor a 3, por lo tanto, tiene que cambiarse.

1 2 3

Ahora ha quedado ordenada la parte izquierda del primer pivote:

1 2 3

- Vamos a ordenar el lado derecho del primer pivote:

8 5

8 no es menor a 8, por lo tanto, tiene que cambiarse.

5 no es mayor a 8, por lo tanto, tiene que cambiarse.
 5 8

La parte derecha del primer pivote ha quedado ordenada:

5 8

- Como ambas partes ya se han ordenado, entonces el vector también ha quedado

ordenado completamente:

1 2 3 4 5 8

El código en C de este método de ordenamiento es el siguiente:

#include <stdio.h>

void qs(int lista[],int limite_izq,int limite_der)

{
int izq,der,temporal,pivote;

izq=limite_izq;
der = limite_der;
pivote = lista[(izq+der)/2];

do{
while(lista[izq]<pivote && izq<limite_der)izq++;
while(pivote<lista[der] && der > limite_izq)der--;
if(izq <=der)
{
temporal= lista[izq];
lista[izq]=lista[der];
lista[der]=temporal;
izq++;
der--;

}while(izq<=der);
if(limite_izq<der){qs(lista,limite_izq,der);}
if(limite_der>izq){qs(lista,izq,limite_der);}

void quicksort(int lista[],int n)

{
qs(lista,0,n-1);
 }

int main(int argc, const char * argv[])

{

int lista[] ={100,56,0,1,-45,2,46,5,9,6,67,23,5};

int size = sizeof(lista)/sizeof(int);

printf("Lista Desordenada \n");

for (int i=0; i<size; i++) {

printf("%d",lista[i]);
if(i<size-1)
printf(",");
}

printf("\n");
quicksort(lista,size);

printf("Lista Ordenada \n");

for (int i=0; i<size; i++) {
printf("%d",lista[i]);
if(i<size-1)
printf(",");
}

return 0;
}

Merge sort o método por mezcla

Al igual que Quick sort, este método de ordenamiento se basa en la técnica de divide y
vencerás. Consiste en dividir el algoritmo en partes hasta tener elementos individuales,
para luego irlos comparando y ordenando en el vector.
El método funciona de la siguiente manera:
- Tenemos como ejemplo un vector de 6 elementos desordenados:

4 3 2 1 8 5

- Dividimos en dos el vector de forma consecutiva, hasta tener elementos

individuales

5 4 3 2
 4 3

5 2

8
1
3 4

5 2

- Una vez que todos los elementos han sido separados, vamos comparando y
ordenando en el mismo orden en el que fueron separados.
Vamos a empezar con los elementos de la izquierda:

3 es menor a 4, por lo tanto, colocamos el 3 primero:

3 4
2

2 es menor a 3, por lo tanto, colocamos el 2 primero:

2 3 4

Ahora continuamos con los elementos de la derecha:

1 es menor a 8, por lo tanto, colocamos el 1 primero:

1 8

1 es menor a 5, por lo tanto, colocamos primero el 1.

5 es menor a 8, por lo tanto, colocamos el 5 después del 1:
 1 5 8

- Ahora que tenemos ambos lados ordenados debemos unirlos, para lo cual
debemos ir comparando y ubicando los elementos como se hizo anteriormente:

8 2 3 4

1 es menor a 2, por lo tanto, colocamos primero el 1.

2 es menor a 5, por lo tanto, lo colocamos después del 1.
3 es menor a 5, por lo tanto, lo colocamos después del 2.
4 es menor a 5, por lo tanto, lo colocamos después del 3.
Como ya no hay más elementos en la izquierda para comparar, entonces
colocamos los elementos restantes, es decir, el 5 y el 8 después del 4. El vector ha
quedado ordenado:

1 2 3 4 5 8

El código en C de este método es el siguiente:

#include <stdio.h>

void merge_sort(int i, int j, int a[], int aux[]) {

if (j <= i) {
return;
}
int mid = (i + j) / 2;

merge_sort(i, mid, a, aux);

merge_sort(mid + 1, j, a, aux);

int pointer_left = i;
int pointer_right = mid + 1;
int k;

for (k = i; k <= j; k++) {

if (pointer_left == mid + 1) {
aux[k] = a[pointer_right];
pointer_right++;
} else if (pointer_right == j + 1) {
aux[k] = a[pointer_left];
pointer_left++;
} else if (a[pointer_left] < a[pointer_right]) {
aux[k] = a[pointer_left];
pointer_left++;
} else {
aux[k] = a[pointer_right];
pointer_right++;
}
}
 for (k = i; k <= j; k++) {
a[k] = aux[k];
}
}

int main() {
int a[100], aux[100], n, i, d, swap;

printf("Enter number of elements in the array:\n");

scanf("%d", &n);

printf("Enter %d integers\n", n);

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

scanf("%d", &a[i]);

merge_sort(0, n - 1, a, aux);

printf("Printing the sorted array:\n");

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

printf("%d\n", a[i]);

return 0;
}