Algoritmos de Ordenamiento

UNIVERSIDAD NACIONAL
MICAELA BASTIDAS DE APURÍMAC
FACULTAD DE INGENIERÍA
ESCUELA ACADÉMICO PROFESIONAL DE INGENIERÍA

INFORMÁTICA Y SISTEMAS
CURSO: ALGORÍTMICA II
ALGORITMOS DE ORDENAMIENTO
ING. FRANCISCO CARI INCAHUANACO
ABANCAY – APURÍMAC
2018
Escuela Académico Profesional de Ingeniería Informática y Sistemas – UNAMBA
ÍNDICE
Pág.
I. BUBBLE SORT (BURBUJA) ............................................................................................................... 1
1.1 Concepto ..................................................................................................................................... 1
1.2 Descripción.................................................................................................................................. 1
1.3 Algoritmo de Burbuja ................................................................................................................. 1
1.4 Pseudocódigo de Algoritmo Burbuja ......................................................................................... 1
1.5 Algoritmo de Burbuja en C ++ .................................................................................................... 2
1.6 Análisis del Algoritmo ................................................................................................................. 2
1.7 Ventajas y Desventajas ............................................................................................................... 2
II. ORDENAMIENTO POR SELECCIÓN (SELECTION SORT) ................................................................... 3
2.1 Definición .................................................................................................................................... 3
2.2 Su funcionamiento:..................................................................................................................... 3
2.3 Características ............................................................................................................................. 3
2.4 Pseudocodigo .............................................................................................................................. 3
2.5 Análisis del Costo Computacional .............................................................................................. 4
2.6 Estabilidad, Ventajas y Desventajas........................................................................................... 4
III. COUNTING SHORT ...................................................................................................................... 7
3.1 Definición .................................................................................................................................... 7
3.2 Tipos de ordenamientos por cuentas ........................................................................................ 7
3.3 Análisis del algoritmo ................................................................................................................. 7
3.4 Pseudocódigo .............................................................................................................................. 8
3.5 código en c++ .............................................................................................................................. 9
IV. QUICK SORT .............................................................................................................................. 11
4.1 Definición .................................................................................................................................. 11
4.2 El ordenamiento de QuickSort ................................................................................................. 11
4.3 Pseudocodigo ............................................................................................................................ 13
4.4 Codificación en C++ ................................................................................................................. 14
4.5 Análisis del Algoritmo ............................................................................................................... 15
4.6 Técnicas de elección del Pivote ................................................................................................ 16
4.7 Técnicas de Reposicionamiento ............................................................................................. 16
V. MERGE SORT ................................................................................................................................. 17
5.1 Definición .................................................................................................................................. 17
5.2 Paso para realizar este algoritmo............................................................................................. 17
5.3 Descripción................................................................................................................................ 17
5.4 Pseudocódigo ............................................................................................................................ 17
5.5 Ventajas y Desventajas ............................................................................................................. 19

5.6 Conclusiones ............................................................................................................................. 19
VI. SHELL SORT ............................................................................................................................... 20
6.1 Definición .................................................................................................................................. 20
6.2 Análisis del Algoritmo ............................................................................................................... 20
6.3 Ventajas y desventajas ............................................................................................................. 20
6.4 Complejidad .............................................................................................................................. 20
6.5 Complejidad Experimental ....................................................................................................... 21
6.6 Pseudocódigo ............................................................................................................................ 22
6.7 Código en C++ ........................................................................................................................... 22
6.8 Conclusiones ............................................................................................................................. 24
VII. SHAKER SORT ............................................................................................................................ 25
7.1 Definición .................................................................................................................................. 25
7.2 Ventajas y Desventajas ............................................................................................................. 27
7.3 Pseudocódigo ............................................................................................................................ 27
7.4 Código en C++ ........................................................................................................................... 28
7.5 Conclusiones ............................................................................................................................. 29
VIII. HEAP SORT ................................................................................................................................ 30
8.1 Definición .................................................................................................................................. 30
8.2 ¿Qué se Heap Sort?................................................................................................................... 30
8.3 ¿Cómo funciona el Heap Sort ? ................................................................................................ 30
8.4 Montículo .................................................................................................................................. 30
8.5 Operaciones con Montículos .................................................................................................... 30
8.6 Complejidad Computacional .................................................................................................... 31
8.7 Código en C++ ........................................................................................................................... 31
IX. INSERTION SORT(INSERIÓN DIRECTA Y INSERCIÓN BINARIA) ................................................ 33
9.1 Inserción Directa ....................................................................................................................... 33
9.2 El Funcionamiento .................................................................................................................... 33
9.3 Ejemplo de Inserción Directa ................................................................................................... 33
9.4 Código en C++ ........................................................................................................................... 34
9.5 Ventajas y Aplicaciones ............................................................................................................ 35
9.6 Inserción Binaria ....................................................................................................................... 35
9.7 Clasificaciones ........................................................................................................................... 35
9.8 Características ........................................................................................................................... 35
9.9 Análisis ...................................................................................................................................... 36
9.10 Pseudocódigo de Inserción Binaria .......................................................................................... 37
9.11 Código en C++ ........................................................................................................................... 38

9.12 Complejidad .............................................................................................................................. 38
9.13 Conclusiones ............................................................................................................................. 39
9.14 Recomendaciones ..................................................................................................................... 39
X. MÉTODO DE ORDENAMIENTO RADIX SORT ................................................................................ 40
10.1 Historia ...................................................................................................................................... 40
10.2 Método De Ordenamiento Radix Sort ..................................................................................... 40
10.3 ¿En qué consiste este método? ................................................................................................ 40
10.4 Características ........................................................................................................................... 40
10.5 Ordenamiento por radix intercambio. .................................................................................... 40
10.6 Ordenamiento por radix directo. ............................................................................................. 41
10.7 Clasificación .............................................................................................................................. 41
10.8 ¿Cómo funciona el método de ordenamiento Radix Sort? ..................................................... 42
10.9 Código en C++ ........................................................................................................................... 42
10.10 El procedimiento para aplicar el algoritmo de Radix. ......................................................... 44
10.11 Ventajas y desventajas de Radix Sort .................................................................................. 45
10.12 Conclusión ............................................................................................................................. 45
BIBLIOGRAFÍA .................................................................................................................................... 46
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.
En la computación 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 muchas técnicas en este ámbito, cada una con características
específicas, y con ventajas y desventajas sobre las demás.
Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar.

En este caso, nos sirven para ordenar vectores o matrices con valores asignados
aleatoriamente. Nos centraremos en los métodos más populares, analizando la
cantidad de comparaciones que realizan, el tiempo que demora y la complejidad
de cada algoritmo.
El propósito principal de un ordenamiento es el de facilitar las búsquedas de los

registros del conjunto ordenado. Un ordenamiento es conveniente usarlo
cuándo se requiere hacer una cantidad considerable de búsquedas y es
importante el factor tiempo.
Es importante destacar que existen diferentes técnicas de ordenamiento como lo

es; el Método Burbuja, que consiste en comparar pares de valores de llaves;
Método Selección, el cual consiste en encontrar el menor de todos los elementos
del arreglo e intercambiarlo; y entre otros métodos.
Esta guía nos permitirá conocer más a fondo cada método de ordenamiento,
desde uno que es más simple hasta el más complejo. Se realizaran
comparaciones en tiempo de ejecución, pre-requisitos de cada algoritmo,
funcionalidad, alcance, etc.
ALGORTIMOS DE MÉTODOS DE ORDENAMIENTO
I. BUBBLE SORT (BURBUJA)
1.1 Concepto
La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento.
Revisa cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos
de posición si están en el orden incorrecto. Es necesario revisar varias veces toda la lista
hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este
algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante
los intercambios, como si fueran pequeñas "burbujas". También es conocido como el
método del intercambio directo. Dado que solo usa comparaciones para operar elementos,
se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.
Este algoritmo es esencialmente un algoritmo de fuerza bruta lógica.
1.2 Descripción
Este es el algoritmo más sencillo probablemente, ideal para empezar, 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.
Un ejemplo del algoritmo

Vamos a ver un ejemplo. Esta es nuestra lista: 4 - 3 - 5 - 2 - 1
Tenemos 5 elementos, es decir, TAM toma el valor 5. Comenzamos comparando el primero
con el segundo elemento. 4 es mayor que 3, así que intercambiamos. Ahora tenemos:
3-4-5-2-1
Ahora comparamos el segundo con el tercero: 4 es menor que 5, así que no hacemos nada.
Continuamos con el tercero y el cuarto: 5 es mayor que 2. Intercambiamos y obtenemos:
3-4-2-5-1
Comparamos el cuarto y el quinto: 5 es mayor que 1. Intercambiamos nuevamente:
3-4-2-1-5
Repitiendo este proceso vamos obteniendo los siguientes resultados:
3-2-1-4-5
2-1-3-4-5
1-2-3-4–5
1.3 Algoritmo de Burbuja

Generalizando el proceso de ordenación se obtiene el siguiente pseudocódigo estructurado
para el algoritmo de burbuja.
i –Variable ordenaciones
j -Variable comparaciones
n - Número de elementos del vector (en C representa el índice mayor)
1.4 Pseudocódigo de Algoritmo Burbuja

inicio
desde i ← 1 hasta n-1 hacer
desde j ← 1 hasta n-i hacer
si elemento[j] > elemento[j+1] entonces
Ing. Francisco Cari I. 1

aux ← V*j+
V*j+ ← V*j+1+
V*j+1+ ← aux
fin_si
fin_desde
fin_desde
fin
1.5 Algoritmo de Burbuja en C ++

int v[]={3, 34, 1, 53, 15, 6};
int j,i, aux;
// Ordenación
for(i=0; i<5; i++)
{ // Comparaciones
for(j=0; j<5-i; j++)
{ // Intercambiar los elementos
if(v[j] > v[j+1])
{ aux=v[j];
v[j]=v[j+1];
v[j+1]=aux;
}
}
}
1.6 Análisis del Algoritmo

Éste es el análisis para la versión no optimizada del algoritmo:
 Estabilidad: Este algoritmo nunca intercambia registros con claves iguales. Por lo
tanto es estable.
 Requerimientos de Memoria: Este algoritmo sólo requiere de una variable
adicional para realizar los intercambios.
 Tiempo de Ejecución: El ciclo interno se ejecuta n veces para una lista de n
elementos. El ciclo externo también se ejecuta n veces. Es decir, la complejidad es
n * n = O(n2). El comportamiento del caso promedio depende del orden de entrada
de los datos, pero es sólo un poco mejor que el del peor caso, y sigue siendo O(n2).
1.7 Ventajas y Desventajas

Ventajas:
 Fácil implementación, no requiere memoria adicional.
Desventajas:
 Muy lento, realiza numerosas comparaciones, realiza numerosos intercambios.
Este algoritmo es uno de los más pobres en rendimiento. Si miras la demostración te
darás cuenta de ello. No es recomendable usarlo. Tan sólo está aquí para que lo
conozcas, y porque su sencillez lo hace bueno para empezar. Ya veremos otros mucho
mejores. Ahora te recomiendo que hagas un programa y lo pruebes. Si tienes dudas
mira el programa de ejemplo.

II. ORDENAMIENTO POR SELECCIÓN (SELECTION SORT)
2.1 Definición
Algoritmo de ordenamiento por Selección (Selection Sort en inglés): Consiste en encontrar el
menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la
primera posición. Luego el segundo más pequeño, y así sucesivamente hasta ordenarlo todo.
Su implementación requiere O(n2) comparaciones e intercambios para ordenar una
secuencia de elementos.
2.2 Su funcionamiento:
 Buscar el mínimo elemento de la lista
 Intercambiarlo con el primero
 Buscar el mínimo en el resto de la lista
 Intercambiarlo con el segundo y en general:
 Buscar el mínimo elemento entre una posición i y el final de la lista
 Intercambiar el mínimo con el elemento de la posición i.
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que

ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que
ordenar un vector de estructuras más complejas, la operación intercambiar sería más
costosa en este caso. Este algoritmo realiza menos operaciones de intercambiar que el de la
burbuja, por lo que lo mejora en algo.
2.3 Características
 Su tiempo de ejecución es O(N2) para el mejor, peor y caso promedio.
 Si el array de datos es A y su tamaño es N, lo que hace el algoritmo, para cada i de
[0...N-2] es intercambiar A[i] con el mínimo elemento del subarray [A[i+1], ...,A[N]].
 Dado que es muy simple de codiﬁcar, aunque no tiene los mejores tiempos de
ejecución, es apropiado utilizarlo para arrays de datos relativamente pequeños.
2.4 Pseudocodigo
Variables: i, j, k, A[100],menor,n
Inicio
Declarar i, menor, k, j: entero
Para i <- 1 hasta n-1 haga
Menor <- A[i]
k <- i
Para j <- i+1 hasta n haga
Si (A[j]<menor) entonces
Menor <- A[j]
k <- j
Fin si
Fin para
A[k] <- A[i]
A[i] <- menor
Fin para
Fin

2.5 Análisis del Costo Computacional

El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un
vector de n términos, tiene que realizar siempre el mismo número de comparaciones. c(n)=
(n2-n)/2 Cada búsqueda requiere comparar todos los elementos no clasificados, de manera
que el número de comparaciones c(n) no depende del orden de los términos, si no del
número de términos; por lo que este algoritmo presenta un comportamiento constante
independiente del orden de los datos. Luego la complejidad es del orden n2.
2.6 Estabilidad, Ventajas y Desventajas

Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en
realidad esta implementación parece ser bastante estable. Se puede verificar esto
ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se verá
claramente que el orden relativo entre ellos es conservado.
Ventajas:
 Este algoritmo realiza menos operaciones de intercambio que el de la burbuja, por lo que
lo mejora en algo.
 Fácil implementación.
 No requiere memoria adicional.
 Realiza pocos intercambios.
 Rendimiento constante: poca diferencia entre el peor y el mejor caso.
Desventajas:
 Lento
 poco eficiente cuando se usa en listas grandes o medianas
 Realiza numerosas comparaciones
Otra desventaja de este algoritmo respecto a otros como el de burbuja o de inserción directa
es que no mejora su rendimiento cuando los datos ya están ordenados o parcialmente
ordenados.
Ejemplos:
Ejemplo 1: Vamos a ordenar la siguiente lista:
4-3-5-2-1
Empezamos tomando el primer elemento el cual es 4; se comparará con todo los elementos
del arreglo y de ello tomará el menor. Lo intercambiamos con el 4 y la lista queda así:
1-3-5-2-4
Ahora buscamos el menor elemento entre la segunda y la última posición. Es el 2. Lo
intercambiamos con el elemento en la segunda posición, es decir el 3. La lista queda así:
1-2-5-3-4
Buscamos el menor elemento entre la tercera posición y la última. Es el 3, que
intercambiamos con el 5:
1-2-3-5-4
El menor elemento entre la cuarta y quinta posición es el 4, que intercambiamos con el 5:
1-2-3-4-5
ya tenemos nuestra lista ordenada.


8 5 7 6 3 9 2 0 1
0 5 7 6 3 9 2 8 1
1 7 6 3 9 2 8 5
2 6 3 9 7 8 5
3 6 9 7 8 5
5 9 7 8 6
6 7 8 9
7 8 9

Supongamos que queremos ordenar estos valores con el algoritmo de selección directa: 45,
52, 21, 37, 49, así pues, n=5
1° pasada: buscamos entre los últimos n (es decir, 5) elementos el menor de todos, y lo
intercambiaremos con la primera posición.
45, 52, 21, 37, 49 → Para buscar el menor, necesitaremos un bucle for que recorra los n
últimos elementos.
45, 52, 21, 37, 49 → El menor es el 21, colocado en tercera posición.
45, 52, 21, 37, 49 → Lo intercambiamos con el de la primera posición.
21, 52, 45, 37, 49 → Ya tenemos uno en orden. Nos quedan los n-1 últimos.
2° pasada: buscamos entre los últimos n-1 (es decir, 4) elementos el menor de todos, y lo
intercambiaremos con la segunda posición.
21, 52, 45, 37, 49 → Recorremos los cuatro últimos y el menor es el 37.
21, 37, 45, 52, 49 → Lo intercambiamos con la segunda posición y ya hay dos en orden.
3° pasada: buscamos entre los últimos n-2 (es decir, 3) elementos el menor de todos, y lo
intercambiaremos con la tercera posición.
21, 37, 45, 52, 49 → El menor es el 45, en tercera posición.
21, 37, 45, 52, 49 → El 45 ya estaba en 3ª posición, así que al intercambiarlo con él mismo,
se queda dónde está. Ya tenemos tres en orden.
4° y última pasada: buscamos entre los últimos n-3 (es decir, 2) elementos el menor de
todos, y lo intercambiaremos con la cuarta posición.
21, 37, 45, 52, 49 → El menor es el 49, en quinta posición.
21, 37, 45, 49, 52 → Lo intercambiamos con la cuarta posición. Ya hay cuatro en orden.
21, 37, 45, 49, 52 → El último está necesariamente en orden también.
CODIGO EN C++
#include<iostream.h>
#include<conio.h>
main()
{ int A[100],n,i,j,menor,k;
cout<<"ingrese la dimensión del vector";
cin>>n;
for(i=1;i<=n;i++)

{ cout<<"A["<<i<<"]:"; cin>>A[i];
}
for (i=1; i<=n-1;i++)
{ menor=A[i];
k=i;
for(j=i+1; j<=n;j++)
{ if(A[j]<menor)
{ menor=A[j];
k=j;
}
}
A[k]=A[i];
A[i]=menor;
}
for(k=1;k<=n;k++)
cout<<A[k]<<endl;
getch();
}

III. COUNTING SHORT
3.1 Definición
El ordenamiento por cuentas (counting sort en inglés) es un algoritmo de ordenamiento en
el que se cuenta el número de elementos de cada clase para luego ordenarlos. Sólo puede
ser utilizado por tanto para ordenar elementos que sean contables (como los números
enteros en un determinado intervalo, pero no los números reales, por ejemplo).
3.2 Tipos de ordenamientos por cuentas

Los 2 tipos de ordenamientos que se pueden realizar son: los internos y los Externos.
a) Los internos: Son aquellos en los que los valores a ordenar están en memoria
principal, por lo que se asume que el tiempo que se requiere para acceder
cualquier elemento sea el mismo (a[1], a[300], etc.).
b) Los externos: Son aquellos en los que los valores a ordenar están en memoria
secundaria (disco, cinta, cilindro magnético, etc.), por lo que se asume que el
tiempo que se requiere para acceder a cualquier elemento depende de la última
posición accesada (posición 1, posición 300, etc.).
3.3 Análisis del algoritmo

Paso 1: consiste en averiguar cuál es el intervalo en que se encuentran los datos a ordenar
valores mínimo y máximo.
Paso 2: luego creamos un vector de números enteros tantos como valores haya en el
intervalo (mínimo, máximo) y cada elemento se le da un valor de cero (0).
Paso 3: tras esto se recorren todos los elementos a ordenar y se cuenta el número de
apariciones de cada elemento (usando el vector que hemos creado).
Paso 4: por ultimo basta con recorrer este vector para tener todos los elementos ordenados.
Consideremos el siguiente ejemplo: Lista a ordenar: 2 5 3 2 8 5 3 2

1º Paso. buscar el mínimo y el máximo:
Mínimo=2
Máximo=8
2º Paso. creamos un vector auxiliar:

Auxiliar=vector *2…8+ que pertenecen a los enteros.
3º Paso. Recorrer la lista de elementos y contar los elementos:

Al final, Auxiliar= [3, 2, 0, 2, 0, 0, 1]
Auxiliar [2] =3 por que el valor 2 aparece 3 veces.
Auxiliar [7] = 0 por que el valor 7 no aparece en la anterior secuencia.
4º Paso. Recorriendo el vector auxiliar obtenemos la lista de números ordenada

Lista ordenada = 2 ,2 ,2 ,3 ,3 ,5 ,5 ,8

3.4 Pseudocódigo
Inicio
Variables (A [15], aux [100], i, j, ma, me, ord;
//ingresamos la dimensión a leer dimensión: n
Hacer para i=1 hasta n
Leer A[i]
si(A[i] > k)
k = A[i]; INGRESO DE DATOS AL ARREGLO
finsi
me=A[i]
finhacer
hacer para i=1 hasta n

si(ma>A[i]) REALIZAR LA BUSQUEDA DEL VALOR
ma=A[i]; MAYOR DEL ARREGLO A[i]
finsi
finhacer
hacer para i=1 hasta n

si(me<A[i]) REALIZAR LA BUSQUEDA DEL MENOR
me=A[i]; VALOR DEL ARREGLO A[i]
ord =1
finsi
finhacer
hacer para i=me hasta ma PRIMER FOR RRECORRE DESDE EL VALOR MENOR
hacer para i=1 hasta n (PROCESO DE CONTEO
si j = A[i] SEGUNDO FOR RRECORRE LOS VALORES DEL ARREGLO A[i]
aux[ord]=A[i]; *DENTRO DEL CONDICIONAL SE REALIZARA LA
COMPARACION (VALOR A[i]CON LA POSICION i CONTEO QUE
ord=ord+1;
VA DESDE EL VALOR MENORMAYOR)
finsi *POR ULTIMO EL OTRO CONDICIONAL SI CUANDO SE DA EL
si A[i]==Aux[ord] CASO DE TENER 2 MISMOS VALORES DENTRO DEL ARREGLO
new_ord1=new_ord-1 DENTRO DEL CUAL COMPARA VALOR A[i] con la posición
finsi CONTEO Y EN EL CASO DE LOS DOS VALORES IGUALES ,UNA
VARIABLE new_ord1 QUE INTRODUCIRA EL VALOR DE LA
POSICION CONTEO EN EL NUEVO ARREGLO Aux[ord] QUE
fin hacer UNA VEZ SE DE EL CASO DE 2 VALORES IGUALES
fin hacer INTRODUCIRA EL PRIMER VALOR REPETIDO ,LUEGO SE
REDUCIRA EN 1 Y INSERTARA EL OTRO VALOR QUE SE REPITE
EN LA SIGUIENTE CASILLA
Hacer para i=1 hasta n MOSTRAR EL ARREGLO ORDENADO EN EL

Leer aux[i] ARREGLO AUX[i]
Fin hacer

3.5 código en c++

#include <iostream.h>
#include <conio.h>
main ()
{ int n,i,j,aux[50],A[50],max,min,ord,new_ord1;
cout<<"TRABAJO GRUPAL"<<endl;
cout<<"INGRESE NUMERO DE ELEMENTOS: ";
cin>>n;
for (i=1;i<=n;i++)
{ cout<<"A["<<i<<"] = ";
cin>>A[i];
}
for(i=1;i<=n;i++)
{ if(A[i]>=max)
max=A[i];
}
for(i=1;i<=n;i++)
{ if(A[i]<=min)
min=A[i];
ord=1;
}
for(j=min;j<=max;j++)
{ for(i=1;i<=n;i++)
{ if(j==A[i])
{ aux[ord]=A[i];
ord=ord+1;
}
If(A[i]==Aux[ord];
{
new_ord1=new_ord_igual-1;
}
}
}
for (i=1;i<=n;i++)
{ cout<<"LOS ELEMENTOS ORDENADOS SON: " <<aux[i]<<endl;
}
getch();
}
Ejemplo1
Lista a ordenar no se repite ningún elemento: 5 2 4 3 1
buscar el mínimo y el máximo:
Mínimo=1
Máximo=5


Al final, Auxiliar= [1, 1, 0, 1, 1]

En Este caso no usaremos variables auxiliares puesto que los valores que tenemos en el
arreglo no se repiten
NO HAREMOS USO  : Auxiliar []

Lista ordenada = 1 2 3 4 5
Ejemplo 2: Lista a ordenar donde se repite un elemento: 2 5 3 2 8 5 3 2

1º Paso. buscar el mínimo y el máximo:
Mínimo=2
Máximo=8


Al final, Auxiliar= [3, 2, 0, 2, 0, 0, 1]
Auxiliar [2] =3 por que el valor 2 aparece 3 veces.
Auxiliar [7] = 0 por que el valor 7 no aparece en la anterior secuencia.

Lista ordenada = 2 ,2 ,2 ,3 ,3 ,5 ,5 ,8

IV. QUICK SORT
4.1 Definición
El algoritmo conocido como Quicksort (ordenamiento rápido) recibe el nombre de su
autor, Tony Hoare. La idea del algoritmo es simple, se basa en la división en particiones de la
lista a ordenar, por lo que se puede considerar que aplica la técnica divide y vencerás. Este
método es posiblemente el más pequeño en cuanto se refiere al código, más rápido, más
elegante, más interesante y eficiente de los algoritmos de ordenamiento conocidos, ya que
permite en promedio, ordenar n-elementos en un tiempo proporcional a n log n.
4.2 El ordenamiento de QuickSort

Sustancial del método de intercambio directo y recibe el nombre de QuickSort por la
velocidad en que ordena los elementos del arreglo. Actualmente el más eficiente y veloz de
los métodos de ordenamiento interno. Es también conocido con el nombre de ordenamiento
rápido.
Este método de ordenamiento es una mejora del algoritmo original es recursivo, pero se
utilizan versiones iterativas para mejorar su rendimiento (los algoritmos recursivos son en
general más lentos que los iterativos, y consumen más recursos).
El método se basa en dividir los “n “ elementos de la lista de ordenar en dos partes o
particiones separadas por un elemento: una partición izquierda , un elemento central
denominado pivote o elemento de partición ,y una partición derecha . La partición o
división se hace de tal forma que todo los elementos de la primera sub-lista (partición
izquierda) son menores que todos los elemento de la segunda sub-lista (partición
derecha). Las dos sub-listas se ordenan entonces independientemente.
Para dividir la lista en particiones (sub-listas) se elige uno de los elementos de la lista y
se utiliza como pivote o elemento de partición .Si se elige una lista cualquiera con los
elementos en orden aleatoria, se puede seleccionar cualquier elemento de la lista como
pivote ,por ejemplo ,el primer elemento de la lista. Si la lista tiene algún orden parcial
conocido, se puede tomar otra decisión paralela pivote. Idealmente ,el pivote se debe
elegir de modo que se divida la lista exactamente por la mitad, de acuerdo al tamaño
relativo de las claves. Por ejemplo, si se tiene una lista de enteros de 1 a 10, 5 o 6 serían
pivotes ideales , mientras que 1 o 10 serían elecciones “pobres” de pivotes.
Una vez que el pivote ha sido elegido , se utiliza para ordenar el resto de la lista en
dos sub-listas : una tiene toda las claves menores que el pivote y la otra todos los
elementos ( claves ) mayores o iguales que el pivote ( o al revés ). Estas dos listas
parciales se ordenan recursivamente utilizando el mismo algoritmo; es decir, se llama
sucesivamente al propio algoritmo quicksort . La lista final ordenada se consigue
concatenando la primera sub-lista , el pivote y la segunda lista , en ese orden , en una
única lista .La primera etapa de quicksort es la división o “ particionado ” recursivo de la
lista hasta que todas las sub-listas constan de sólo un elemento.
La elección del pivote es muy importante, pues el buen funcionamiento del quicksort
depende en gran medida de lo balanceadas que queden las particiones.

Podemos pensar en varias formas de calcular el elemento pivote, a continuación

proponemos algunas:
- Usar el primer elemento del vector: esta solución funciona bien cuando la entrada es
completamente aleatoria, pero será muy deficiente si la entrada está ordenada (O(n 2)),
también será muy deficiente si la entrada está parcialmente ordenada (este caso se da
frecuentemente).
- Pivote aleatorio: es más seguro que la alternativa anterior, pero tiene los
inconvenientes de la generación de los números aleatorios, ya que si estos son de buena
calidad es una operación costosa.
- Mediana de 3: se trata de calcular la mediana de 3 elementos del vector. Lo ideal sería
poder calcular la mediana de todos los elementos, de esta forma sería lo más balanceado
posible, pero esto es muy costoso, por lo que calculando la mediana de 3 elementos
podemos evitar de manera eficiente el peor caso.
T[i] (primer elemento)
T[j] (último elemento)
T[(i+j) div 2]
Análises
1. Ingresamos 5 números cualquiera
8 0 3 1 4
2. Se elige el pivote
Pivote=(primero +ultimo)/2
Pivote=A[(0+4)/2]=A[2]=3
Pivote
8 0 3 1 4
3. Para la izquierda tienen que estar los “i” menores

 8 0 3  1 4
3.1.-se compara para los pivote menores que 3
4. Para la derecha tiene que estar los “j” mayores

4.1. Se comprara para los pivote mayores que 3
5. Como 8 no es menor que 3 y1 no es mayor que tres se intercambian

1 0 3 8 4
6. Ahora se va poder dividir en tres partes

Sub-lista izquierda
1 0

Sub-lista derecha
8 4
Pivote
3
7. En la sub-lista izquierda como pivote se toma a cualquiera de ellos.
7.1. En este caso se va tomar 1 como pivote para luego comparar
0 1
7.2.-en este caso como pivote se va a tomar al 8 para luego comparar

8 4
8. El arreglo ordenado seria:

0 1 3 4 8
4.3 Pseudocodigo
inicio
variables B: arreglo[100] entero
variables n,i,j,: entero
variables primero, ultimo: entero
escribir(ingrese dimensión de array)
leer (n)
escribir (ingrese elemento)
para i = 1 hasta n
leer(B[i])
Fin para
quicksort(B,0,n-1)
escribir (B,n)
Fin
Funcion quicksort(A[100], primero, ultimo: entero)

Variable central, pivote: entero
central = (primero + ultimo) / 2
pivote= A[central]
i = primero
j = ultimo
hacer
mientras A[i]<pivote
i=i+1
mientras A[j]>pivote
j=j-1
si i <= j
entero temp
temp = A[i]
A[i] = A[j]
A[j] = temp
i = i+1

j = j-1
fin si
fin hacer
mientras i <= j
si primero < j
quicksort(A,primero,j)
fin si
si i < ultimo
quicksort(A,i, ultimo)
fin si
fin funcion quicksort
funcion escribir(A[100],n: entero)
i: entero
escribir (arreglo ordenado ascendentemente)
para i=1 hasta n
escribir (A[i])
fin para
fin funcion escribir
4.4 Codificación en C++

La función quicksort ( ) refleja el algoritmo citado anteriormente; esta función se llama
pasando como primer argumento el array B[ ] y los índices que le delimitan 0 y nro-1
(índice inferior y superior). La llamada a la función.
#include<conio.h>
void quicksort(double [20],int, int);
void escribir(double [20],int );
main()
{ int i,nro;
double B[20];
cout<<" Ingrese la diomension del arreglo"<<endl;
cin>>nro;
cout<<" Ingree elementos del arreglo"<<endl;
for(i=0;i<nro;i++)
{ cout<<"B["<<i<<"]= ";
cin>>B[i];
}
cout<<" ARREGLO ORIGINAL "<<endl;
for(i=0;i<nro;i++)
{ cout<<" "<<B[i];
}
quicksort(B,0,nro-1);
escribir(B,nro);
getch();
}

void quicksort(double A[20],int primero,int ultimo)

{ int central,i,j;
double pivote;
central=(primero+ultimo)/2;
pivote=A[central];
i=primero;
j=ultimo;
do {
while(A[i]<pivote) i++;
while(A[j]>pivote) j--;
if(i<=j)
{ double temp;
temp=A[i];
A[i]=A[j]; /*intercambia A[i] con A[j] */
A[j]=temp;
i++;
j--;
}
}
while(i<=j);
if(primero<j)
quicksort(A,primero,j); /*mismo proceso con sublista izquierda*/
if(i<ultimo)
quicksort(A,i,ultimo); /*mismo proceso con sublista derecha*/
}
void escribir(double A[20], int n)
{ int i;
cout<<endl<<" ELEMENTOS ORDENADOS "<<endl;
for(i=0;i<n;i++)
{ cout<<" "<<A[i];
}
cout<<endl;
}

Como se puede suponer, la eficiencia del algoritmo depende de la posición en la que termine
el pivote elegido.
Estabilidad: El algoritmo no es estable.
Memoria: No requiere memoria adicional en su forma recursiva. En su forma iterativa la

necesita para la pila.
Ventajas: El algoritmo básico Quicksort permite tomar cualquier elemento de la lista como
pivote, dependiendo de la partición n que se elija, el algoritmo será más o menos eficiente.

Tomar un elemento cualquiera como pivote tiene la ventaja de no requerir ningún cálculo
adicional, lo cual lo hace bastante rápido. Sin embargo, esta elección «a ciegas» siempre
provoca que el algoritmo tenga un orden de O(n²) para ciertas permutaciones de los
elementos en la lista.
 Muy rápido.
 No requiere memoria adicional.
Desventajas: En el peor caso, el pivote termina en un extremo de la lista. El orden de

complejidad del algoritmo es entonces de O(n²) . El peor caso dependerá de la
implementación del algoritmo, aunque habitualmente ocurre en listas que se encuentran
ordenadas, o casi ordenadas.
Pero principalmente depende del pivote, si por ejemplo el algoritmo implementado toma
como pivote siempre el primer elemento del array, y el array que le pasamos está ordenado,
siempre va a generar a su izquierda un array vacío, lo que es ineficiente.
 Implementación un poco más complicada.
 Recursividad (utiliza muchos recursos).
 Mucha diferencia entre el peor y el mejor caso
4.6 Técnicas de elección del Pivote

El algoritmo básico del método Quicksort consiste en tomar cualquier elemento de la lista al
cual denominaremos como pivote, dependiendo de la partición en que se elija, el algoritmo
será más o menos eficiente.
Tomar un elemento cualquiera como pivote tiene la ventaja de no requerir ningún cálculo
adicional, lo cual lo hace bastante rápido. Sin embargo, esta elección «a ciegas» siempre
provoca que el algoritmo tenga un orden de O(n²) para ciertas permutaciones de los
elementos en la lista.
4.7 Técnicas de Reposicionamiento

Una idea preliminar para ubicar el pivote en su posición final sería contar la cantidad de
elementos menores que él, y colocarlo un lugar más arriba, moviendo luego todos esos
elementos menores que él a su izquierda, para que pueda aplicarse la recursividad.
Existe, no obstante, un procedimiento mucho más efectivo. Se utilizan dos índices: i, al que
llamaremos índice izquierdo, y j, al que llamaremos índice derecho. El algoritmo es el
siguiente:
Recorrer la lista simultáneamente con i y j: por la izquierda con i (desde el primer elemento),
y por la derecha con j (desde el último elemento).

V. MERGE SORT
5.1 Definición
El algoritmo de Ordenamiento por mezcla (Merge sort) es un algoritmo de ordenación
externo estable basado en la técnica divide y vencerás. Es de complejidad O(n log n).
Este algoritmo consiste: Consiste en dividir en dos partes iguales el vector a ordenar,
ordenar por separado cada una de las partes, y luego mezclar ambas partes, manteniendo el
orden, en un solo vector ordenado.
Creador: Este algoritmo fue desarrollado por el matemático Húngaro John Von Neumann en
1945.
Para que sirve: El algoritmo MergeSort (u Ordenamiento por mezcla) es un algoritmo

que sirve para ordenar secuencias de datos.
5.2 Paso para realizar este algoritmo
DIVIDIR: divide la secuencia de "n" elementos a ordenar en dos sub secuencias de

"n/2" elementos cada una.
VENCER: ordena las dos sub secuencias de manera recursiva mediante el algoritmo
MERGESORT.
COMBINAR: combina las dos sub secuencias ordenadas para generar la solución.
5.3 Descripción
Conceptualmente, el ordenamiento por mezcla funciona de la siguiente manera:
Si la longitud de la lista es 0 ó 1, entonces ya está ordenada. En otro caso:
Dividir la lista desordenada en dos sub listas de aproximadamente la mitad del
tamaño.
Ordenar cada sub lista recursivamente aplicando el ordenamiento por mezcla.
Mezclar las dos sub listas en una sola lista ordenada.
El ordenamiento por mezcla incorpora dos ideas principales para mejorar su tiempo de
ejecución:
1º Una lista pequeña necesitará menos pasos para ordenarse que una lista grande.
2º Se necesitan menos pasos para construir una lista ordenada a partir de dos listas
también ordenadas, que a partir de dos listas desordenadas. Por ejemplo, sólo será
necesario entrelazar cada lista una vez que están ordenadas.
A continuación se describe el algoritmo en pseudocódigo (se advierte de que no se
incluyen casos especiales para vectores vacíos, etc.; una implementación en un
lenguaje de programación real debería tener en cuenta estos detalles):
5.4 Pseudocódigo
#include <iostream>
using namespace std;
//modulo para llenar datos en el arreglo

void leeArreglo(int arreglo[],int n)

{ for(int i=1;i<=n;i++)
{ cout<<"igrese valor en la posicion ["<<i<<"]"<<endl;
cin>>arreglo[i];
}
}
//fin ingreso de datos
void mostrar_arreglo(int arreglo[],int n)
{ for(int i=1;i<=n;i++)
{ cout<<"El valor en la poicion ["<<i<<"] es: "<<arreglo[i]<<endl;
}
}
void merge(int A[],int B[],int der,int mit,int izq)
{ int i,fin_der,num_elem,pos_temp;
fin_der=mit-1;
pos_temp=der;
num_elem=izq-der+1;
while (der<=fin_der and mit<=izq)
{ if(A[der]<=A[mit])
{ B[pos_temp]=A[der];
pos_temp=pos_temp+1;
der=der+1;
}
else { B[pos_temp]=A[mit];
mit=mit+1;
}
}
while (der<=fin_der)
{ B[pos_temp]=A[der];
der=der+1;
}
while (mit<=izq)
{ B[pos_temp]=A[mit];
mit=mit+1;
}
for(i=1;i<=num_elem;i++)
{ A[izq]=B[izq];
izq=izq-1;
}
}
void orden_mergesort(int der,int izq,int arregloA[],int arregloB[])
{ int mit;
if(izq>der)
{ mit=(izq+der)/2;

orden_mergesort(der,mit,arregloA,arregloB);
orden_mergesort(mit+1,izq,arregloA,arregloB);
merge(arregloA,arregloB,der,mit+1,izq);
}
}
int main(int argc, char *argv[])
{ int dim;
int arregloA[50];
int arregloB[50];
cout<<"ingrese dimension del arreglo:"<<endl;
cin>>dim;
leeArreglo(arregloA,dim);//llamando al modulo para ingresar datos
cout<<"Los datos del arreglo son:"<<endl;
mostrar_arreglo(arregloA,dim);
cout<<endl;
cout<<endl;
cout<<"Aplicando mergesort:"<<endl;
orden_mergesort(1,dim,arregloA,arregloB);
mostrar_arreglo(arregloA,dim);
return 0;
}

Ventajas: Tiene la ventaja de que utiliza un tiempo proporcional a: n log (n),
Su algoritmo presenta mucha estabilidad.
el tiempo que emplea en ordenar es mucho más rápido que todos los métodos de
ordenamiento que conocemos.
Desventajas: Radica en que se requiere de un espacio de memoria adicional del

tamaño de los datos a ordenar en el cual se realizan las mezclas.
Su algoritmo está definido recursivamente.
5.6 Conclusiones
El estudio de algoritmos de ordenamiento tiene una gran importancia dentro de la Ciencia
de la Computación, pues una buena cantidad de los procesos realizados por medios
computacionales requieren que sus datos estén ordenados. Además, el hecho de
almacenar los datos de manera ordenada permite implementar algoritmos de búsqueda
muy rápidos (por ejemplo: búsqueda binaria). Esta y muchas otras razones de fin práctico
impulsaron el estudio y la búsqueda de algoritmos de ordenamiento eficientes.

VI. SHELL SORT
6.1 Definición
El método de ordenamiento del Shell Sort es una generalización del ordenamiento por
inserción y mejora comparando elementos ingresados separados por un espacio de varias
posiciones. Esto permite que un elemento haga con saltos de mayor tamaño 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.
Este método también se conoce con el nombre de inserción con incrementos decrecientes.
Shell modifico los saltos contiguos resultantes de las comparaciones por saltos de mayor
tamaño y con eso se conseguía la clasificación más rápida. El método se basa en fijar el
tamaño de los saltos constantes, pero de más de una posición.
El último paso del Shell Sort es un simple ordenamiento por inserción.

Estabilidad: Este algoritmo nunca intercambia registro con claves iguales por lo tanto es
estable.
Requerimiento de memoria: Este método de ordenamiento de Shell Sort de una variable

adicional pasa realizar los intercambios.
Tiempo de ejecución: Dependiendo de la elección de la secuencia de espacios, Shell Sort

tiene un tiempo de ejecución en el peor caso de O(n2) (usando los incrementos de Shell que
comienzan con 1/2 del tamaño del vector y se dividen por 2 cada vez.
La secuencia de espacios debe comenzar con (N / 2)y dividir por la mitad el número hasta
alcanzar 1
6.3 Ventajas y desventajas
Ventajas
 Fácil implementación
 Es un algoritmo muy simple teniendo un tiempo de ejecución aceptable
 Es uno de los algoritmos más rápidos.
 No requiere memoria adicional.
 Ordena de manera burbuja, pero más rápido
Desventajas
Su complejidad es difícil de calcular y depende mucho de la secuencia de Incrementos que
utilice.
Shell Sort es un algoritmo no es estable porque se puede perder el orden relativo
6.4 Complejidad
 Dependiendo de la elección de la secuencia de espacios, Shell sort tiene un tiempo de
ejecución en el peor caso de O(n2) (usando los incrementos de Shell que comienzan con
1/2 del tamaño del vector y se dividen por 2 cada vez.
 La existencia de una implementación O(nlogn) en el peor caso del Shell sort permanece
como una pregunta por resolver.

6.5 Complejidad Experimental

La grafica se obtuvo con las siguientes condiciones de entrada:
Aleatorio: Tiempo de ejecución para 50 tiempos generados de manera aleatoria, con
incrementos de 2000 en el tamaño del vector.
Ordenado: Tiempo de ejecución para 50 arreglos ordenados anticipadamente.

Incrementos de 2000.
Desordenado: Tiempo de ejecución para 50 arreglos que contienen datos ordenados de

Mayor a Menor. Incrementos de 2000.
Ejemplo: ordenar las siguientes claves del arreglo A: 15, 67, 8, 16, 44, 27, 12,35.
Primero se realiza el número de saltos:

Nº de saltos = (cantidad de elementos/2)
Para el ejemplo  Nº de saltos = (8/2)=4
Paso 1
Los elementos saltan de 4 en 4 y si cumple que a>b  a toma el lugar de b y b toma el lugar
de a:
15, 67, 8, 16, 44, 27, 12, 35
La ordenación se produce:
15, 67, 8, 16, 44, 27, 12, 35
15, 67, 8, 16, 44, 27, 12, 35  No hay cambios a hacer
15, 27, 8, 16, 44, 67, 12, 35  El 67 se sustituye por el (67>27)
Paso 2
Los elementos van en saltos de 2 en 2; porque después de haber hecho la 1º pasada el salto
se divide entre 2.
15, 27, 8, 16, 44, 27, 12, 35
La ordenación se produce: 15, 27, 8, 16, 44, 27, 12, 35
8, 27, 15, 16, 44, 27, 12, 35  El 15 se sustituye por el 8 ,15>8
8, 16, 15, 27, 44, 67, 12, 35  El 27 se sustituye por el 16 ,27>16
8, 16, 15, 27, 12, 67, 44, 35  El 44 se sustituye por el 12,44>12
Otra vez se procede con salto 2 hasta que no haya elementos a comparar.

Paso 3
Los elementos van en saltos de 1 en 1 porque después de haber hecho la 2da pasada el salto
se divide entre 2; se realiza porque en la 2da pasada ya hay cambios.

Otra vez procede con salto 1 hasta que no haya elementos a comparar
La ordenación produce:
8, 12, 15, 16, 27, 35, 44, 67  Ya está ordenado.
6.6 Pseudocódigo
6.7 Código en C++

#include<conio.h>
int Arreglo[10];

void LeerArreglo(int Numero);

void EscribeArreglo(int Numero);
void Shell(int Numero);
void main()
{ int Num;
cout<<"Ingrese Numero Elementos: ";
cin>>Num;
LeerArreglo(Num);
Shell(Num);
cout<<endl;
EscribeArreglo(Num);
getch();
}
void LeerArreglo(int Numero)
{ int i;
for(i=1;i<=Numero;i++)
{ cout<<"Arreglo["<<i<<"]=";
cin>>Arreglo[i];
}
}
void EscribeArreglo(int Numero)
{ int i;
for(i=1;i<=Numero;i++)
{cout<<"Arreglo["<<i<<"]="<<Arreglo[i]<<endl;
}
}
void Shell(int Numero)
{ int i,j,incremento,aux;
incremento=Numero/2;
while(incremento>0)
{ for(i=incremento+1;i<=Numero;i++)
{ j=i-incremento;
while(j>0)
{ if(Arreglo[j]>=Arreglo[ j +incremento])
{ aux = Arreglo[j];
Arreglo[j] = Arreglo[j+incremento];
Arreglo[j+incremento] = aux;
}
else
{ j=0;
}
j=j-incremento;
}
}
incremento=incremento/2;
}
}

6.8 Conclusiones
 Este algoritmo eficaz, relativamente eficiente en la mayoría de los casos, fácil de
implementar, no consume memoria extra dinámicamente y se comporta bastante bien
para unos datos de entrada de mediano tamaño.
 Es un algoritmo de ordenación interna muy sencillo pero muy ingenioso, basado en
comparaciones e intercambios, y con unos resultados radicalmente mejores que los que
se pueden obtener con el método de la burbuja, el de selección directa o el de inserción
directa.
 Tiene una gran importancia dentro de la Ciencia de la Computación, pues una buena
cantidad de los procesos realizados por medios computacionales requieren que sus
datos estén ordenados.

VII. SHAKER SORT
7.1 Definición
Esta es una mejora al método de la burbuja, ya que su manera de trabajar de este algoritmo
es ir ordenado al mismo tiempo por los dos extremos del vector.
Se llama "Shaker", ya que da el efecto de un movimiento de agitación o sacudida a la matriz.
Aunque este método de sacudida es una mejora al método de la burbuja, su complejidad del
algoritmo sigue siendo O(n²).
Este método consta de dos etapas:
Este método consta de dos etapas:
 La Primera.- “De Derecha A Izquierda” se traslada los elementos más pequeños hacia la
parte izquierda del arreglo, almacenando en una variable la posición del último elemento
intercambiado.
 La Segunda.- “De Izquierda A Derecha” se traslada los elementos más grandes hacia la
parte derecha del arreglo, almacenando en otra variable la posición del último elemento
intercambiado.
Esto termina cuando en una etapa no se producen intercambios o bien cuando el contenido
de la variable que almacena el extremo izquierdo del arreglo es mayor que el contenido de la
variable que almacena el extremo derecho.
Factores que afectan directamente al tiempo de ejecución del algoritmo:
 Las comparaciones entre los elementos.
 Los intercambios entre los mismos.
 Las pasadas que se realizan
Ejemplo:
//Sean los elementos que conforman el vector A:[7,6,2,8,1,5,3,4]
Primera pasada:
Trasladaremos el elemento menor a la izquierda comparando cada elemento
Primera etapa:
A:[7,6,2,8,1,5,3,4]
[3>4] no ==> No hay intercambio A:[6,7,2,8,1,5,3,4]
[5>3] si ==> Si hay intercambio A:[6,7,2,8,1,3,5,4]
A: [1, 6, 7, 2, 8, 3, 5, 4]
El primer valor ordena 1

El menor número ya está en su posición ahora de izquierda a derecha buscaremos el
elemento mayor y lo llevaremos a la derecha.
Segunda etapa:
A: [1,6,7,2,8,3,5,4]


A: [1, 6, 2, 7, 3, 5, 4, 8]
El segundo valor ordena 8

El menor número ya está en su posición ahora de izquierda a derecha buscaremos el
segundo elemento mayor y lo llevaremos a la izquierda.
Segunda Pasada
Trasladaremos el segundo elemento menor a la izquierda comparando cada elemento
Primera etapa:
A: [1,6,2,7,3,5,4,8]
A:[1,2,6,3,7,4,5,8]
El tercer valor ordenado 2
Segunda etapa:
De izquierda a derecha
A: [1, 2, 6, 3, 7, 4, 5, 8]
A: [1, 2, 3, 6, 4, 5, 7, 8]
El cuarto valor ordenado 7
De derecha a izquierda
A: [1, ,3, 4, 6, 5, 7, 8]
El quinto valor ordenado 3
De izquierda a derecha
A: [1, 2, 3, 4, 5, 6, 7, 8]
El sexto valor ordenado 6

De derecha a izquierda
El séptimo valor ordenado 4
Como el valor 5 ya no tiene con quien compararse se queda en su posición que le

corresponda
Concluimos que el vector A: [1, 2, 3, 4, 5, 6, 7, 8] esta ordenado ascendentemente.

Ventajas
- Fácil Implementación.
- No requiere memoria adicional.
- Reduce el número de comparaciones.
- Se va directamente al elemento que va ordenar.
Desventajas
- Muy lento.
- Realiza muchas comparaciones.
- Realiza numerosas intercambios.
- Es inestable, no mantiene el orden relativo de los registros
7.1 Factores que afectan directamente al tiempo de ejecución del algoritmo

Son los siguientes
 Las comparaciones con los elementos
 Los intercambios entre los mismos
 Las pasadas que realizan
7.3 Pseudocódigo
Proceso ShakerSort
Escribir "Ingrese el número de elementos"
Leer tam
Dimension v[20]
Para i<-1 Hasta tam Hacer
Escribir "V[",i,"]"
Leer v[i]
FinPara
//Asignación de los Valores
izq <- 2
der <- tam
ultimo <- tam
Repetir
//Codigo del ordenamiento a la izquierda
Para i <- der hasta izq hacer//Los valores menores van a la izquierda
Si v[i-1] > v[i] entonces//der va disminuyendo en 1 hsta llegar a izq
aux <- v[i]
v[i] <- v[i-1]
v[i-1] <- aux

ultimo <- i
FinSi
FinPara
izq <- ultimo+1
// Codigo del ordenamiento a la derecha
Para j <- izq hasta der hacer //Los valores mayores van a la derecha
Si (v[j-1] > v[j]) entonces
aux <- v[j]
v[j] <- v[j-1]
v[j-1] <- aux
ultimo <- j
FinSi
FinPara
der <- ultimo-1
Hasta Que (izq > der)
//imprimimos el nuevo arreglo
Escribir "nuevo arreglo"
Para i<-1 Hasta tam Hacer
Escribir v[i]
FinPara
7.4 Código en C++
#include <iostream>
{ int izq,der, aux,i,N,k;
float A[20];
cout<<"ingrese dimencion del arreglo ==> "; cin>>N;
k=N;
izq=2;
der=N;
for(i=1;i<=N;i++)
{ cout<<"A["<<i<<"]="; cin>>A[i];
}
while(izq<der)
{ for(i=der;i>=izq;i--)
{ if (A[i-1]>A[i])
{ aux=A[i-1];
A[i-1]=A[i];
A[i]=aux;
k=i;
}
}
izq=k+1;
for(i =izq ;i<=der;i++)
{ if(A[i-1]>A[i])

{ aux=A[i-1];
A[i-1]=A[i];
A[i]=aux;
k=i;
}
}
der=k-1;
}
for(i=1;i<=N;i++)
cout<<A[i]<<" ";
return 0;
}
7.5 Conclusiones
La utilización del Método Shaker o “sacudida” es el ordenamiento de un vector que se
requiere ordenar independiente de su tamaño, este ordenamiento se basa en la
implementación de comparaciones más completas entre todos los dígitos del vector, esto
hace más sencillo su uso y manera de entenderlo. Teniendo en cuenta la forma del algoritmo
que se desee utilizar, podemos ver e identificar, que utilizando este método por consola es
mucho más cortas las líneas de código que imprimiendo cada uno de los mensajes
requeridos.
La intención de este doble direccionamiento es ayudar a los elementos “tortugas” a

“avanzar” de manera más rápida.

VIII. HEAP SORT
8.1 Definición
El heap o montículo es un árbol binario donde todos los padres son mayores que sus hijos.
Este árbol binario tiene que ser completo, es decir, que debe tener todos los niveles llenos,
excepto el último y en este último nivel todos los hijos están en un mismo lado (por ejemplo
en la derecha).
8.2 ¿Qué se Heap Sort?

 Es un algoritmo de ordenamiento basado en comparaciones de elementos que utiliza un
heap para ordenarlos.
 También podemos decir que es un algoritmo de ordenamiento no recursivo, no estable,
con complejidad computacional o (n log n).
8.3 ¿Cómo funciona el Heap Sort ?

Este algoritmo consiste en almacenar todo los elementos del vector a ordenar en montículos
y luego extrae de modo que como raíz en sucesivas iteraciones obteniendo el conjunto
ordenado. Basa su funcionamiento en una propiedad de montículos, por lo cual, la cima
siempre dependiendo de cómo se definan contendrá el mayor o menor elemento del
montículo.
8.4 Montículo
Un montículo (heap en inglés) es una estructura de datos del tipo árbol con información
perteneciente a un conjunto ordenado. Los montículos máximos tienen la característica de
que cada nodo padre tiene un valor mayor que el de todos sus nodos hijos, mientras que en
los montículos mínimos, el valor del nodo padre es siempre menor al de sus nodos hijos.Un
árbol cumple la condición de montículo si satisface dicha condición y además es un árbol
binario completo. Un árbol binario es completo cuando todos los niveles están llenos, con la
excepción del último, que se llena desde la izquierda hacia la derecha.
En un montículo de prioridad, el mayor elemento (o el menor, dependiendo de la relación de
orden escogida) está siempre en el nodo raíz. Por esta razón, los montículos son útiles para
implementar colas de prioridad. Una ventaja que poseen los montículos es que, por ser
árboles completos, se pueden implementar usando arreglos, lo cual simplifica su codificación
y libera al programador del uso de punteros.
8.5 Operaciones con Montículos

Las operaciones más importantes o básicas en un montículo son la de inserción y la de
eliminación de uno o varios elementos.
Cómo se inserta un elemento en un montículo.

Esta operación parte de un elemento y lo inserta en un montículo aplicando su criterio de

ordenación. Si suponemos que el montículo está estructurado de forma que la raíz es mayor
que sus hijos, comparamos el elemento a insertar (incluido en la primera posición libre) con
su padre. Si el hijo es menor que el padre, entonces el elemento es insertado correctamente,
si ocurre lo contrario sustituimos el hijo por el padre.
¿Y si la nueva raíz sigue siendo más grande que su nuevo padre?. Volvemos a hacer otra vez
dicho paso hasta que el montículo quede totalmente ordenado. En la imagen adjunta vemos
el ejemplo de cómo realmente se inserta un elemento en un montículo. Aplicamos la
condición de que cada padre sea mayor que sus hijos, y siguiendo dicha regla el elemento a
insertar es el 12. Es mayor que su padre, siguiendo el método de ordenación, sustituimos el
elemento por su padre que es 9 y así quedaría el montículo ordenado.
Eliminar
En este caso eliminaremos el elemento máximo de un montículo. La forma más eficiente de
realizarlo sería buscar el elemento a borrar, colocarlo en la raíz e intercambiarlo por el
máximo valor de sus hijos satisfaciendo así la propiedad de montículos de máximos. En el
ejemplo anterior representado vemos que 20 es el elemento máximo y es el sujeto a
eliminar.
1. Eliminar el elemento máximo (colocado en la raíz).
2. Hemos de subir el elemento que se debe eliminar, para cumplir la condición de
montículo a la raíz, que ha quedado vacía.
3. Una vez hecho esto queda el último paso el cual es ver si la raíz tiene hijos mayores que
ella si es así, aplicamos la condición y sustituimos el padre por el mayor de sus
progenitores.
1
20 8
1
18 9
0
9
8
10
8
8.6 Complejidad Computacional

Es la que estudia, de manera teórica, la complejidad inherente a la resolución de un
problema computable. Los recursos comúnmente estudiados son el tiempo (mediante una
aproximación al número y tipo de pasos de ejecución de un algoritmo para resolver un
problema) y el espacio (mediante una aproximación a la cantidad de memoria utilizada para
resolver un problema). Se pueden estudiar igualmente otros parámetros, tales como el
número de procesadores necesarios para resolver el problema en paralelo. La teoría de la
complejidad difiere de la teoría de la computabilidad en que ésta se ocupa de la factibilidad
de expresar problemas como algoritmos efectivos sin tomar en cuenta los recursos
necesarios para ello.
8.7 Código en C++

#include<conio.h>
int main ()

{ int i,j,k,n,item,temp;
int A[10];
Cout<<” ingrese la dimension ”<<endl;
Cin>>n;
for (i=1;i<=n;i++)
{ cin>>A[i];
}
for (k=n;k>0;k--)
{ for (i=1;i<=k;i++)
{ item=A[i];
j=j/2;
while (j>0 && A[i]<item)
{ A[i]=A[j];
i=j;
j=j/2;
}
A[i]=item;
}
temp=A[1];
A[1]=A[k];
A[k]=temp;
}
cout<<endl;
cout<<”el orden es ”<<endl;
for (i=1;i<=n;i++)
{ cout<<”*”<<i<<”+ valor es_:”<<””<<A*i+<<endl;
}
getch();
}

IX. INSERTION SORT(INSERIÓN DIRECTA Y INSERCIÓN BINARIA)
9.1 Inserción Directa

El método de inserción directa es el que generalmente utilizan los jugadores de cartas
cuando ordenan éstas, de ahí que también se conozca con el nombre de método de la
baraja.
La idea central de este algoritmo consiste en insertar un elemento del arreglo en la parte
izquierda del mismo, que ya se encuentra ordenada. Este proceso se repite desde el segundo
hasta el n-esimo elemento.
9.2 El Funcionamiento
Se basa en el concepto de que en la iteración i-ésima los i primeros elementos se encuentran
ordenados entre ellos.
De ello se deduce que no es necesario ejecutar el bucle con un valor i = 1, ya que un
elemento siempre está ordenado con respecto a si mismo; es por ello que el bucle en este
algoritmo debe de empezar por el valor 2.
En una iteración i concreta, la forma de llevar a cabo la ordenación consiste en colocar el
elemento i-ésimo en su posición correcta con respecto a los i-1 anteriores, que están
ordenados entre ellos.
Para proceder de esta manera se comparará el elemento i-ésimo con todos los anteriores,
hasta que se encuentre uno que sea menor o igual que él, o se llegue al principio del vector
(en este caso el elemento i-ésimo es el más pequeño).
9.3 Ejemplo de Inserción Directa

Ahora veamos un ejemplo ordenando de menor a mayor (ascendentemente) la siguiente
lista de números: 7, 3, 10, 1, 9
La lista tiene 5 elementos, con lo cual tendremos que recorrer la lista 4 veces. Ya que
la comparación se hará desde el segundo elemento de la lista, es decir recorremos la lista
después del primer elemento hasta el último.
1er. recorrido: Se toma 3 para comparar con los elementos anteriores. Los elementos
anteriores son: 7
3
7 10 1 9
La comparación 3<7, es verdadera, entonces desplazamos el 7 una posición a la derecha.
3
7 10 1 9
Al no haber más elementos a comparar colocamos el 3 en la posición del último elemento
desplazado.
3 7 10 1 9
2do. recorrido: Se toma 10 para comparar con los elementos anteriores. Los elementos
anteriores son: 3, 7
10
3 7 1 9
La comparación 10<7, es falsa, entonces no desplazamos nada y se termina este recorrido.
3 7 10 1 9

3er. recorrido: Se toma 1 para comparar con los elementos anteriores. Los elementos
anteriores son: 3, 7, 10
1
3 7 10 9
1
3 7 10 9
1
3 7 10 9
1
3 7 10 9
Al no haber más elementos a comparar colocamos el 1 en la posición del último elemento
desplazado.
1 3 7 10 9
4to. recorrido: Se toma 9 para comparar con los elementos anteriores. Los elementos
anteriores son: 1, 3, 7, 10
9
1 3 7 10
La comparación 9<10 es verdadera, entonces desplazamos el 10 una posición a la derecha.
9
1 3 7 10
La comparación 9<7 es falsa, entonces no desplazamos nada y se termina este recorrido,
colocando el 9 en la posición del último elemento desplazado.
1 3 7 9 10
Con este último recorrido la lista ya está ordenada. Tal como se puede observar, cada
recorrido termina cuando se encuentra una posición en donde colocar el elemento tomado
o cuando ya no haya elementos con que comparar. Bien ahora el siguiente procedimiento
sería la primera implementación del algoritmo:
9.4 Código en C++
#include <iostream>

{ int A[100], n, i, k, aux;
cout<<"ingrese la dimension del vector: ";
cin>>n;
for(i=1;i<=n;i++){
cout<<"A["<<i<<"]:";
cin>>A[i];
}
for(i=2;i<=n;i++)

{ aux=A[i];
k=i-1;
while((k>=1)&&(aux<A[k]))
{ A[k+1]=A[k];
k=k-1;
}
A[k+1]=aux;
}
for(k=1;k<=n;k++)
{ cout<<"el orden es: ";
cout<<A[k]<<endl;
}
return 0;
}
9.5 Ventajas y Aplicaciones

 Fácil de Implementar
 Eficiente en pocos datos
 Eficiente en datos que ya tienen cierta tendencia al orden
2
 Más eficiente en la práctica que otros algoritmos de ordenamiento de tipo O(n )
2
porque su tiempo promedio es de n /4 y es lineal en su mejor caso
 Estable (no cambia el orden relativo de los elementos iguales)
 Es un algoritmo "en línea" (puede ordenar elementos conforme los recibe).
 Aunque este algoritmo tiene un mejor orden de complejidad que el de burbuja,
es muy ineficiente al compararlo con otros algoritmos como quick sort.
 Es el método más sencillo de programar, no requiere espacio extra.
9.6 Inserción Binaria

Este método se basa en considerar una parte de lista ordenada y situar cada uno de los
elementos insertándolo en el lugar que le corresponda por su valor, todos los valores a
la derecha se desplazan una posición para dejar espacio.
9.7 Clasificaciones
El algoritmo de inserción directa se mejora fácilmente al notar que la secuencia
destino Aj...Ai-1, donde debe insertarse el nuevo elemento, ya está ordenada. Por eso
puede ser empleado un método más rápido para determinar el punto de inserción. La
elección obvia es una búsqueda binaria que prueba la secuencia destino en la mitad y
continúa buscando hasta encontrar el punto de inserción. El algoritmo de clasificación
modificado recibe el nombre de inserción binaria.
 La secuencia destino donde debe insertarse el nuevo elemento ya está ordenada.
 Búsqueda Binaria para localizar el lugar de inserción.
 Desplazar elementos.
 Insertar.

9.9 Análisis
Al realizar la búsqueda binaria se divide una longitud L por la mitad un número determinado
de veces.
A. Hallamos el elemento central del área comprendida por la parte ordenada más la posición
del elemento a insertar.
B. Comparamos el elemento central con el elemento que queremos insertar. Si dicho
elemento central es menor o igual, nos quedamos con la parte derecha (Sin incluir el
elemento central). En caso contrario, nos quedamos con la parte izquierda incluyendo al
elemento central.
C. Repetimos el mismo proceso sobre el área con la que nos quedamos, hasta que dicha área
sea nula.
D. Cuando el área sea nula, tendremos la posición de inserción.
El proceso comienza comparando el elemento central del arreglo con el valor buscado. Si
ambos coinciden finaliza la búsqueda. Si no ocurre así, el elemento buscado será mayor o
menor en sentido estricto que el central del arreglo. Si el elemento buscado es mayor se
procede a hacer búsqueda binaria en el sub array superior, si el elemento buscado es menor
que el contenido de la casilla central, se debe cambiar el segmento a considerar al segmento
que está a la izquierda de tal sitio central.
Ejemplo de inserción binaria
15 67 08 16 44 27 12 35
Primera pasada:
15<67 no hay intercambio
15 67 08 16 44 27 12 35
Segunda pasada:
15<08 Si hay intercambio
15 67 08 16 44 27 12 35
Tercera pasada:
15<16 No hay intercambio
08 15 67 16 44 27 12 35
08 15 16 67 44 27 12 35
Cuarta pasada:
08 15 16 44 67 27 12 35

Quinta pasada:
08 15 16 27 44 67 12 35
Sexta pasada:
08 15 12 16 27 44 67 35

08 12 15 16 27 44 67 35
Séptima pasada:
08 12 15 16 27 35 44 67
9.10 Pseudocódigo de Inserción Binaria

Sea A un arreglo unidimensional de N elementos.
Donde i, aux, izq, der, m, j son variables de posición de tipo entero
Repetir con i donde 1 hasta n.
Aux=a[i]
Izq=1
Der=i-1
Mientras izq<=der Repetir
M=izq+der/2
si aux<=a[m] entonces
Der=m-1
Sino
Izq=m+1
Fin si
Fin mientras
j=i-1
Mientras j>=izq
A[j+1]=a[j]
A[izq]=aux
Fin del ciclo

9.11 Código en C++

//insercion binaria
#include <iostream>

{ int vector[100],i,j,n;
int izq,der,aux,m;
cout<<"ingrese la dimension del vector:";
cin>>n;
for(i=1;i<=n;i++)
{ cout<<"A["<<i<<"]:";
cin>>vector[i];
}
for(i=1;i<=n;i++)
{ aux=vector[i];
izq=1;
der=i-1;
while(izq<=der)
{ m=(int)(izq+der)/2;
if(aux<=vector[m])
{ der=m-1;
}
else
{ izq=m+1;
}
}
j=i-1;
while(j>=izq)
{ vector[j+1]=vector[j];
j=j-1;
}
vector[izq]=aux;
}
for(i=1;i<=n;i++)
{ cout<<"el ordenamiento es: ";
cout<<vector[i]<<endl;
}
return 0;
}
9.12 Complejidad
Los métodos de ordenación por inserción lineal e inserción binaria, solo se diferencias entre
sí, conceptualmente, en el método de la búsqueda. Por lo tanto, el número de movimientos
de claves será el mismo en ambos casos es
n(n-1)

2. En cuanto al número de comparaciones, cuando el intervalo tiene i elementos, se realizan

log2(i) comparaciones. Por lo tanto, el número de comparaciones es:
C=i=1n-1 log2(i)=1n-1 log2(x)dx=nlog2(n)
Es decir, el número de comparaciones O(nlog2n), y el número de movimientos es On2.
9.13 Conclusiones
Concluimos que la búsqueda binaria es un algoritmo muy eficiente para minimizar el tiempo
de búsqueda ,la cual consiste en dividir el intervalo de búsqueda en dos partes comparando
el elemento buscado con el elemento central, estos mismos pasos se repetirá hasta
encontrar el elemento buscado. Este método es más efectivo que la inserción directa porque
hay menos comparaciones al hacer la búsqueda. A diferencia no tiene que comparar con
todos los elementos anteriores hasta encontrar el bueno. Pero es también es un algoritmo
lento para números muy grande o sea “N” números.
9.14 Recomendaciones
Lo recomendable es que antes de usar este algoritmo este los numero en un orden
adecuado o arreglo ordenado parar poder pero puede ser de utilidad para listas que están
ordenadas o semi ordenadas, porque en ese caso realiza muy pocos desplazamientos.

X. MÉTODO DE ORDENAMIENTO RADIX SORT
10.1 Historia
Se dice que este método nació de la idea de Herman Hollerith en 1890 al crear la maquina
tabuladora, en la cual se empleaban tarjetas perforadas para realizar el censo de ese año en
Estados Unidos.
Al final, después de unas horas, la maquina entregaba todo un grupo de hojas listas para ser
procesadas en un computador.
En el censo de 1880 se tomaron 10 años para procesar toda la información, pero con las tarjetas
perforadas, en la máquina que incluía un “card sorter” se tomaron cerca de 6 semanas.
La idea original de Hollerith era ordenar empezando por el digito más significativo. Es de esta
forma que surgió una maquina ordenadora de tarjetas. La cual, utilizando el método de Radix-
Sort, concatenaba cada hoja dependiendo de la ubicación de las ultimas 3 columnas, que
contenían las cifras para el acomodo de tarjetas, estando numerado del 0 al 9.
10.2 Método De Ordenamiento Radix Sort

El algoritmo de Ordenamiento por bases o Radix Sort, ordena los números tomando en
cuenta el valor relativo que tienen las cifras o dígitos de un número en un determinado
sistema de numeración. Se pueden ir agrupando o contando los números, desde las cifras
menos significativas a las más significativas ó en sentido contrario. El conteo o agrupación de
los números se hace tomando en cuenta la base del sistema de numeración que se elija para
ordenar.
10.3 ¿En qué consiste este método?

Consiste en ir acomodando los números primero por unidades, luego por decenas, centenas,
etc. No hace comparaciones entre datos.
• El Radix trabaja en memoria principal y pertenece al grupo de intercambio.
• Efectúa sus operaciones sobre dígitos individuales de los números que representan a
las claves cuando estas pertenecen a un sistema numérico en cualquier base.
• Este método se puede considerar como una generalización de la clasificación por
urnas.
• La idea clave de la ordenación radix-sort es clasificar por urnas primero respecto al
digito de menor peso hasta alcanzar el digito más significativo.
• Si la cantidad de dígitos es grande, en ocasiones es más eficiente ordenar el archivo
aplicando primero el ordenamiento de raíz a los dígitos más significativos y después
utilizando inserción directa sobre el archivo ordenado.
• La característica de este algoritmo está en que no hace comparaciones para ordenar
las listas, simplemente se encarga de ir contando o agrupando los números que
tengan el mismo valor relativo en determinada cifra.
10.5 Ordenamiento por radix intercambio.

El algoritmo se puede detallar como:
Clasificar las claves según su bit binario más significativo, de forma que todas las claves que
tengan un primer 0 estén antes de aquella Z.
 Que tenga un primer 1.

En este paso ya se diferencia notablemente dos grupos, el formado por las claves que
comienzan con 0, y el formado por las claves que comienzan con 1. Ahora se aplica de nuevo
el primer paso a cada grupo formado pero con el bit siguiente.
Ejemplo: Se tiene la siguiente lista de números binarios (y su correspondiente en decimal)

los cuales se ordenaran con Radix: 1001 (9), 0011 (3), 1111 (15), 1110 (14), 1011 (11), 0000
(0). Entonces sucede lo siguiente según el algoritmo Radix intercambio descrito en la sección
característica.
Lista desordenada en 9 3 15 14 11 0
decimal
Claves iniciales 1001 0011 1111 1110 1011 0000
Primer intercambio 0011 0000 1001 1111 1110 1011
Segundo intercambio 0011 0000 1001 1011 1111 1110
Tercer Intercambio 0000 0011 1001 1011 1111 1110
Cuarto intercambio 0000 0011 1001 1011 1110 1111
Lista ordenada en 0 3 9 11 14 15
decimal
10.6 Ordenamiento por radix directo.

Esta variante del ordenamiento Radix consiste en examinar los bits de la clave de derecha a
izquierda individualmente, e ir posicionando respectivamente de acuerdo a su valor de
clave.
10.7 Clasificación
Existen dos clasificaciones de Radix Sort:
 Radix Sort LSD

Procesa las representaciones de enteros empezando por el dígito menos significativo y
moviéndose hacia el dígito más significativo. (De derecha a izquierda).
El método más aplicado de Radix, es el LSD, y se encarga de colocar los números en una de
las 10 colas que representan un digito cada una de ella, iniciando desde la cola que controla
el digito 0 hasta la cola que controla el digito 9, en estas colas se colocan los números
dependiendo del digito que se esté analizando en ese momento, hasta que termine con el
número que contenga la mayor cantidad de dígitos, en cada cambio de digito los elementos
se integran al arreglo nuevamente desde la cola 0 hasta la cola 9, para elegir el siguiente
digito de ordenamiento. Cuando se efectúa este proceso para cada dígito al arreglo está
ordenado.
 Radix Sort MSD

Trabaja en sentido contrario.
- De derecha a izquierda y
- De izquierda a derecha.
El Radix MSD procesa los enteros iniciando por el digito más significativo y moviéndose al
digito menos significativo (de izquierda a derecha).
• Usa orden léxico, que es ideal para la ordenación de cadenas de caracteres, como las
palabras o representaciones de enteros de longitud fija.

• Una secuencia como "b, c, d, e, f, g, h, i, j, ba" será ordenada léxicamente como "b, ba, c,
d, e, f, g, h, i, j".
Si se usa orden léxico para ordenar representaciones de enteros de longitud variable,
entonces la ordenación de las representaciones de los números del 1 al 10 será "1, 10, 2, 3,
4, 5, 6, 7, 8, 9", como si las claves más cortas estuvieran justificadas a la izquierda y
rellenadas a la derecha con espacios en blanco, para hacerlas tan largas como la clave más
larga, para el propósito de este ordenamiento.
10.8 ¿Cómo funciona el método de ordenamiento Radix Sort?

El más grande de dos enteros de igual longitud se determina del modo siguiente:
 Empezar en el dígito más significativo y avanzar por los dígitos menos significativos
mientras coinciden los dígitos correspondientes en los dos números.
 El número con el dígito más grande en la primera posición en la cual los dígitos de los
dos números no coinciden es el mayor de los dos (por supuesto sí coinciden todos los
dígitos de ambos números, son iguales).
 Ordena el arreglo en una forma estable.
Ejemplo:
Supongamos la siguiente lista de números enteros.
Haremos diversos montones de fichas caracterizados por contener el mismo dígito

(leyendo el número de derecha a izquierda).
Cada montón es recogido en orden ascendente, y vuelve a repartirse con el siguiente

dígito.
De ésta forma terminamos con una lista ordenada de forma ascendente. Hay que resaltar
que aunque el número 93 ya se encontraba ordenado desde antes de la concatenación de
igual forma se tuvo que mover de urna (Urna tres) para lograr la lista final.
10.9 Código en C++
#include <math.h>
#include <conio.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define NUMELTS 20

Using namespace STD;

void radixsort (int x [], int n)
{ Int front [10], rear [10];
Struct
{ Int info;
Int next;
} node [NUMELTS];
int exp, first, i, j, k, p, q, y;
for (i = 0; i < n-1; i++)
{ node[i].info = x[i];
node[i].next = i+1;
}
node [n-1].info = x [n-1];
node [n-1].next = -1;
first = 0;
for (k = 1; k < 5; k++)
{ for (i = 0; i < 10; i++)
{ rear[i] = -1;
front[i] = -1;
}
While (first! = -1)
{ p = first;
first = node [first].next;
y = node[p].info;
exp = pow (10, k-1);
j = (y/exp) % 10;
q = rear[j];
If (qs == -1)
front[j] = p;
else
Node[q].next = p;
Rear[j] = p;
}
for (j = 0; j < 10 && front[j] == -1; j++);
first = front[j];
while (j <= 9)
{ for (i = j+1; i < 10 && front[i] == -1; i++);
if (i <= 9)
{ p = i;
node [rear[j]].next = front[i];
}
j = i;
}
node [rear[p]].next = -1;
}
for (i = 0; i < n; i++)
{ X[i] = node [first].info;

first = node [first].next;

}
}
int main (void)
{ int x [50] = {null}, i;
static int n;
int m;
printf ("cadena de numeros enteros positivos: \n");
scanf (“%d", &m);
cout<<"---------"<<endl;
for (n = 0; n<m; n++)
if (! scanf ("%d", &x[n])) break;
if (n)
radixsort (x, n);
for (i = 0; i < n; i++)
printf ("%d ", x[i]);
getch ();
}
10.10 El procedimiento para aplicar el algoritmo de Radix.

i). Determinar cuál es la mayor cantidad de dígitos del elemento mayor del arreglo.
ii). Crear un arreglo de colas, que permita almacenar cada uno de los dígitos del 0 al
9.
iii). Crear cada posición del arreglo como un objeto que permita almacenar los
elementos en cada cola, según el índice que le corresponde.
iv). Generar un ciclo que determine el número de digito que se esta procesando y el
factor que permite encontrar el digito.
 Inicializar el número de digito y el factor en uno;
 Mientras el digito sea menor o igual a la cantidad de dígitos encontrados en
el paso uno.
 El número de digito se debe incrementar de uno en uno.
v). Crear un segundo ciclo que se encuentra dentro del anterior y que se encarga de
recorrer todo el arreglo desde la posición inicial hasta la final del arreglo.
 Iniciar el control del ciclo en cero.
 Mientras el control sea menor al tamaño del arreglo, continuamos en el
ciclo.
 El control del ciclo se cambia de uno en uno.
vi). Generar un segundo ciclo que se encuentra dentro del primero, al igual que el
anterior y este controla el paso de los elementos de las colas al arreglo
nuevamente.
 El control de este ciclo inicia desde la cola cero, al igual que el índice que
controla el arreglo de los elementos.
 Mientras el control sea menor a diez continua dentro del ciclo.
 El control del ciclo se incrementa de uno en uno.
vii). Dentro del ciclo anterior se genera otro ciclo que se encarga de colocar el
contenido de cada cola dentro del arreglo original y su condición es que mientras

la cola no este vacía retire los elementos guardándolos en el arreglo e

incrementar el índice que controla el arreglo.
10.11 Ventajas y desventajas de Radix Sort

Ventajas.
 Es un ordenamiento es estable siempre y cuando su algoritmo este bien hecho y bien
implementado en un lenguaje de programación.
 El ordenamiento es razonablemente eficiente si el número de dígitos en las claves que se
van a ordenar no es demasiado grande.
 Si las máquinas tienen la ventaja de ordenar los dígitos (sobre todo si están en binario) lo
ejecutarían con mucho mayor rapidez de lo que ejecutan una comparación de dos claves
completas.
Desventajas
 Se requiere conocer la cantidad de dígitos del valor máximo (para saber cuándo el
método ya acomodo todos los elementos).
 Radix no es muy eficiente cuando las claves son extremadamente largas.
 Se da gran pérdida de tiempo cuando son muy pocas claves, lo que se podría
implementar más eficientemente con otro ordenamiento.
 Cuando las claves no están muy distribuidas entre ellas, si no son muy
secuenciales la clasificación Radix no es recomendable, debido a que podría estar
sujeto a pérdida de memoria y tiempo.
 Se requiere de espacio para almacenar los punteros del frente y de la parte
posterior de la cola, además de un campo adicional en cada registro que se utiliza
como puntero a la lista encadenada.
10.12 Conclusión
Radix Sort es potencialmente un algoritmo muy eficiente gracias a una complejidad lineal en
el número de datos a ordenar. Desde un punto de vista del algoritmo secuencial Radix sort
muestra una pobre exploración de la jerarquía de memoria cuando los conjuntos quedan
en el segundo o en el tercer nivel. Desde un punto de vista del algoritmo paralelo la solución
básica puede tener un gran desequilibrio de carga en cada interacción del algoritmo
(ordenación de cada digito).
Radix sort es uno de los algoritmos de clasificación para lineales enteros. Funciona mediante
la clasificación de los números de entrada de cada dígito, para cada uno de los dígitos de los
números. Sin embargo, el proceso adoptado por este método de ordenación es poco
intuitivo, en el sentido de que los números se ordenan en el dígito menos significativo
primero, seguido por el segundo al menos dígitos significativos y así sucesivamente hasta
que el dígito más significativo.

BIBLIOGRAFÍA
Libros
 Algotrabajo\Apuntes de Algoritmos y Programación Shell Sort.htm
 Carrasco Muñoz Joel, (2006) “creación de programas con Borland C++”, primera edición,
Lima.
 Micha Hofri, Analysis of Algorithms: Computational Methods and Mathematical
 Robert Sedgewick (1998), Algorithms in C++, third edition, editorial Addison-Wesley
 Savitch, Walter (2007), ”Resolución de problemas con C++”, quinta edición, Prentice Hall,
México.
 Sara Baase (1999), Computer Algorithms: Introduction to Design and Analysis,
Editorial Pearson, 3rd edition
Páginas en internet
 https://upcanalisisalgoritmos.wikispaces.com/file/view/ALGORITMOS+DE+ORDENAMIEN
TO+COUNTINGSORT.pdf
 http://lwh.free.fr/pages/algo/tri/tri_es.htm
http://lwh.free.fr/pages/algo/tri/tri_insertion_es.html
http://lwh.free.fr/pages/algo/tri/tri_bulle_es.html
http://lwh.free.fr/pages/algo/tri/tri_shaker_es.html
http://lwh.free.fr/pages/algo/tri/tri_gnome_es.html
http://lwh.free.fr/pages/algo/tri/tri_selection_es.html
http://lwh.free.fr/pages/algo/tri/tri_peigne_es.html
http://lwh.free.fr/pages/algo/tri/tri_shell_es.html
http://lwh.free.fr/pages/algo/tri/tri_rapide_es.html
 http://books.google.com.co/books?id=NLngYyWFl_YC&pg=PA168&lpg=PA168&dq=coun
ting+sort+cormen&source=bl&ots=BwVsEE-
 http://www.angelfire.com/wy2/est_info/quicksort.html
 http://algoritmia.net/articles.php?id=31
 https://es.scribd.com/document/19540984/RADIX

Algoritmos de Ordenamiento

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Algoritmos de Ordenamiento

Hochgeladen von

Copyright:

Verfügbare Formate

UNIVERSIDAD NACIONAL

MICAELA BASTIDAS DE APURÍMAC

ESCUELA ACADÉMICO PROFESIONAL DE INGENIERÍA

ING. FRANCISCO CARI INCAHUANACO

5.5 Ventajas y Desventajas ............................................................................................................. 19

9.11 Código en C++ ........................................................................................................................... 38

Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar

Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar.

El propósito principal de un ordenamiento es el de facilitar las búsquedas de los

Es importante destacar que existen diferentes técnicas de ordenamiento como lo

ALGORTIMOS DE MÉTODOS DE ORDENAMIENTO

I. BUBBLE SORT (BURBUJA)

Un ejemplo del algoritmo

1.3 Algoritmo de Burbuja

1.4 Pseudocódigo de Algoritmo Burbuja

Ing. Francisco Cari I. 1

1.5 Algoritmo de Burbuja en C ++

1.6 Análisis del Algoritmo

1.7 Ventajas y Desventajas

Ing. Francisco Cari I. 2

II. ORDENAMIENTO POR SELECCIÓN (SELECTION SORT)

Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que

Ing. Francisco Cari I. 3

2.5 Análisis del Costo Computacional

2.6 Estabilidad, Ventajas y Desventajas

Ing. Francisco Cari I. 4

Ejemplo 2: Vamos a ordenar la siguiente lista:

Ejemplo 3: Vamos a ordenar la siguiente lista:

Ing. Francisco Cari I. 5

Ing. Francisco Cari I. 6

III. COUNTING SHORT

3.2 Tipos de ordenamientos por cuentas

3.3 Análisis del algoritmo

Consideremos el siguiente ejemplo: Lista a ordenar: 2 5 3 2 8 5 3 2

2º Paso. creamos un vector auxiliar:

3º Paso. Recorrer la lista de elementos y contar los elementos:

4º Paso. Recorriendo el vector auxiliar obtenemos la lista de números ordenada

Ing. Francisco Cari I. 7

hacer para i=1 hasta n

hacer para i=1 hasta n

Hacer para i=1 hasta n MOSTRAR EL ARREGLO ORDENADO EN EL

Ing. Francisco Cari I. 8

3.5 código en c++

1º Paso. creamos un vector auxiliar:

2º Paso. Recorrer la lista de elementos y contar los elementos:

Ing. Francisco Cari I. 9

NO HAREMOS USO  : Auxiliar []

3º Paso. Recorriendo el vector auxiliar obtenemos la lista de números ordenada

Ejemplo 2: Lista a ordenar donde se repite un elemento: 2 5 3 2 8 5 3 2

2º Paso. creamos un vector auxiliar:

3º Paso. Recorrer la lista de elementos y contar los elementos:

4º Paso. Recorriendo el vector auxiliar obtenemos la lista de números ordenada

Ing. Francisco Cari I. 10

IV. QUICK SORT

4.2 El ordenamiento de QuickSort

Ing. Francisco Cari I. 11

Podemos pensar en varias formas de calcular el elemento pivote, a continuación

3. Para la izquierda tienen que estar los “i” menores

3.1.-se compara para los pivote menores que 3

4. Para la derecha tiene que estar los “j” mayores

5. Como 8 no es menor que 3 y1 no es mayor que tres se intercambian

6. Ahora se va poder dividir en tres partes

Ing. Francisco Cari I. 12

7.2.-en este caso como pivote se va a tomar al 8 para luego comparar