ORDENAMIETOS

La ordenacin o clasificacin es el proceso de organizar datos en algn orden o

secuencia especfica, tal como creciente o decreciente, para datos numricos,
o alfabticos, para datos de caracteres.
Los mtodos de ordenacin ms directos son los que se realizan en el espacio
ocupado por el array. Los ms populares son:
1. Mtodo De Intercambio O De Burbuja:
La Ordenacin de burbuja (Bubble Short en ingls) es un sencillo algoritmo de
ordenamiento. Funciona revisando cada elemento de la lista que va a ser
ordenada con el siguiente, intercambindolos de posicin si estn en el orden
equivocado.
Se basa en el principio de comparar pares de elementos adyacentes e
intercambiarlos entre si hasta que estn todos ordenados.
Supongamos que se desea clasificar en orden ascendente el vector o lista:
50 15 56 14 35 1 12 9
A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]
Los pasos a dar son:
Comparar A[1] y A[2] si estn en orden, se mantienen como estn, en
caso contrario se intercambian entre s.
A continuacin se comparan los elementos 2 y 3; de nuevo se
intercambian si es necesario.
El proceso continua hasta que cada elemento del vector ha sido
comparado con sus elementos adyacentes y se han realizado los
intercambios necesarios.
Un ejemplo en seudocdigo es:
Desde el 1 hasta 7 hacer
Si elemento [I] <elemento [I + 1] entonces
Intercambiar (elemento [I], elemento [I + 1]
fin_si
fin_ desde

PUBLIC SUB
Main()
Ejemplos de ordenamiento por el mtodo
burbuja:
Public
num As Integer
DIM Columna AS Integer
Public numeritos As String
DIM N, i, j, Aux AS Integer
Public Sub Form_Open()
DIM Limite AS Integer
DIM vector AS Integer[]
vector = NEW Integer[]
PRINT Ingrese el limite mximo a leer el
vector:
INPUT Limite
FOR Columna = 0 TO Limite
PRINT Ingresa un Numero
INPUT N
vector.Add(N)
NEXT
Este es el Procedimiento Burbuja
para ordenar los datos que contiene
el vector
FOR i = 0 TO Limite 1
FOR j = 0 TO Limite 1
IF Vector[j] > vector[j + 1] THEN
En esta parte se realiza el intercambio
Aux = vector[j]
vector[j] = vector[j + 1]
vector[j + 1] = Aux
END IF
NEXT
NEXT
PRINT
Por ultimo procedemos a imprimir el
vector
FOR j = 0 TO Limite
PRINT vector[j]
NEXT
END
2. Ordenamiento Por Insercin

Me.Center
End
Public Sub Button1_Click()
Dim arrayNum As Integer[] = ["55", "86", "48",
"16", "82"]
Dim x, y, a, s, Rota1, Rota2 As Integer
TextArea1.Clear
Repeat
If a = 4 Then a = 0
If y = 4 Then y = 0
If arrayNum[y] < arrayNum[a + 1] Then
Inc y
Inc a
Inc s
Continue
Endif
Rota1 = 0
Rota2 = 0
Rota1 = arrayNum[y]
Rota2 = arrayNum[a + 1]
arrayNum[y] = Rota2
arrayNum[a + 1] = Rota1
Dec s
For Each num In arrayNum
numeritos &= num & " "
Wait 0.2
Next
TextArea1.Text &= numeritos & gb.NewLine
numeritos = ""
Until s > 4
For Each num In arrayNum
numeritos &= num & " "
Wait 0.2
Next
TextArea1.Text &= gb.NewLine & "Resultado
final es: " & numeritos & gb.NewLine
End

Consiste en insertar un elemento en el vector en una parte ya ordenada de

este vector y comenzar de nuevo con los elementos restantes. Por ser utilizado
generalmente por los jugadores de cartas se le conoce tambin por el mtodo
de la baraja.
Por ejemplo, supngase que se tiene la lista desordenada;
5
14 24 39 43 65 84 45
Seudocdigo:
Algoritmo Clas_insercion1
Para insertar el elemento 45, habr que insertar entre 43 y 65, lo que supone
//declaraciones
desplazar
a la derecha todos aquellos nmeros de valor superior a 45, es decir,
saltar sobre 65 y 84.
Inicio
5. . .14 24 39

43

65 84 45

//ordenacin
2 hasta
N comparaciones
hacer
ElDesde
mtodoI se
basa en
y desplazamientos sucesivos. El
algoritmo de clasificaciones de un vector X para N elementos se realiza con un
AUXI X [I]
recorrido de todo el vector y la insercin del elemento correspondiente en el
lugar
K I -adecuado.
1
ElSW
recorrido
false se realizaza desde el segundo elemento al n-simo.
Desde
i 2 hasta
N hacer
mientras
no (SW)
y (k >= 1) hacer
Insertar
lugar adecuado
si AUXIX[i]
< X en
[ ] el
entonces
Entre
X [ Kx+[1].
1 ] .XX[ [i
K -] 1]
fin_desde
K [K 1]
Esta
accin repetitiva - insertar- se realiza ms fcilmente con la inclusin de
si_no
un valor centinela o bandera. (SW).
SW verdad
fin_si
fin_mientras
X [ K + 1 ] AUXI
fin_desde
fin

3. Ordenacin Por Seleccin

Este mtodo se basa en buscar el elemento menor del vector y colocarlo en

primera posicin. Luego se busca el segundo elemento ms pequeo y se
coloca en la segunda posicin, y as sucesivamente.
Los pasos sucesivos a dar son:
Seleccionar el electo menor del vector de n elementos.
Intercambiar dicho elemento con el primero.
Repetir estas operaciones con los n - 1 elementos restantes,
seleccionando el segundo elemento; continuar con los n - 2
elementos restantes hasta que solo quede el mayor.
Para la comprensin del mtodo usaremos un ejemplo:
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este
caso el menor elemento es la primera 'a'. De manera que no ocurre ningn
cambio. Luego se procede a buscar el siguiente elemento y se encuentra la
segunda 'a'.
Esta se intercambia con el dato que est en la segunda posicin, la 's',
quedando el arreglo as despus de dos recorridos: a =
['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la
cual se intercambia con lo que est en la tercera posicin, o sea, la 'o'. Le sigue
la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a =
['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente
posicin hasta ordenar todo el arreglo.
El nmero de comparaciones que realiza este algoritmo es:
Para el primer elemento se comparan n-1 datos, en general para el elemento isimo se hacen n-i comparaciones, por lo tanto, el total de comparaciones es:
la sumatoria para i de 1 a n-1 (n-i) = 1/2 n (n-1).
Seudocdigo:
Inicio
Desde I 1 hasta n - 1 hacer
Buscar elemento menor de X [ I], X [ I + 1 ], . . . , X [N ] e
intercambiar con X [ I ]
fin_desde
Fin.

4.- Ordenacin por el Mtodo Shell

Es una mejora del mtodo de insercin directa que se utiliza cuando el nmero
de elementos a ordenar es grande. Nombrado as debido a su inventor Donald
Shell. Ordena subgrupos de elementos separados K unidades (respecto de su
posicin en el arreglo) del arreglo original. El valor K es llamado incremento.
Despus de que los primeros K subgrupos han sido ordenados (generalmente
utilizando INSERCION DIRECTA), se escoge un nuevo valor de K ms pequeo, y
el arreglo es de nuevo partido entre el nuevo conjunto de subgrupos. Cada uno
de los subgrupos mayores es ordenado y el proceso se repite de nuevo con un
valor ms pequeo de K.
Eventualmente el valor de K llega a ser 1, de tal manera que el subgrupo
consiste de todo el arreglo ya casi ordenado.
Al principio del proceso se escoge la secuencia de decrecimiento de
incrementos; el ltimo valor debe ser 1."Es como hacer un ordenamiento de
burbuja pero comparando e intercambiando elementos."
Cuando el incremento toma un valor de 1, todos los elementos pasan a formar
parte del subgrupo y se aplica insercin directa.
El mtodo se basa en tomar como salto N/2 (siendo N el nmero de elementos)
y luego se va reduciendo a la mitad en cada repeticin hasta que el salto o
distancia vale 1.
Un ejemplo de su algoritmo es:
const
MAXINC = _____;
incrementos = array[1..MAXINC] of integer;
var
j,p,num,incre,k:integer;
begin
for incre := 1 to MAXINC do begin /* para cada uno de los incrementos
*/
k := inc[incre]; /* k recibe un tipo de incremento */

for p := k+1 to MAXREG do begin /* insercin directa para el grupo

que se encuentra cada K posiciones */
num := reg[p];
j := p-k;
while (j>0) AND (num < reg[j]) begin
reg[j+k] := reg[j];
j := j - k;
end;
reg[j+k] := num;
end
end
end;
Ejemplo:
Para el arreglo a = [6, 1, 5, 2, 3, 4, 0]
Tenemos el siguiente recorrido:

Recorrido

Salto

Lista
Ordenada

Intercambio

2,1,4,0,3,5,6

(6,2), (5,4),
(6,0)

0,1,4,2,3,5,6

(2,0)

0,1,4,2,3,5,6

Ninguno

0,1,2,3,4,5,6

(4,2), (4,3)

0,1,2,3,4,5,6

Ninguno