Está en la página 1de 16

UNIVERSIDAD CONTINENTAL DE CIENCIAS E INGENIERÍAS

INGENIERÍA INFORMÁTICA
IV SEMESTRE

2007

Métodos de Ordenamiento Codificados


en C++

MÉTODOS DE
ORDENAMIENTO
TÉCNICAS DE PROGRAMACIÓN I

• DESCRIPCIÓN

• PROGRAMA COMPLETO DE CADA MÉTODO

o ORDENACIÓN POR SELECCIÓN
GRUPO DE TRABAJO:
o ORDENACIÓN POR INSERCIÓN DIRECTA
SAFORAS CONTRERAS DANNY H.
o ORDENACIÓN POR INSERCIÓN BINARIA
VELAZCO MENDOZA LUIS.
o ORDENACIÓN SHELL SORT
GUTIERREZ ZUÑIGA CESAR.
o ORDENACIÓN QUICK SORT
CORTIJO PACHECO MIGUEL.
o ORDENACIÓN HEAP SORT
BRAÑEZ ROMÁN SERGIO.

ZARATE ROY
ORDENAMIENTO

Es  la operación  de arreglar los registros  de una tabla en algún orden secuencial  de 


acuerdo a un criterio de ordenamiento. El ordenamiento se efectúa con base en el valor 
de algún campo en un registro. El propósito principal  de un ordenamiento  es el de 
facilitar las búsquedas de los miembros del conjunto ordenado. 

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

 
1. ORDENAMIENTO POR SELECCIÓN

DESCRIPCIÓN.

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

ANÁLISIS DEL ALGORITMO.

• Requerimientos   de   Memoria:  Al   igual   que   el   ordenamiento   burbuja,   este 


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

Ventajas: 

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

Desventajas: 

• Lento. 
• Realiza numerosas comparaciones. 
CODIFICACIÓN EN C++

#include<iostream>
using namespace std;
#include"leearreglo.h"
#define largo 50
void seleccionsort (int A[], int n)
{
int min,i,j,aux;
for (i=0; i<n-1; i++)
{
min=i;
for(j=i+1; j<n; j++)
if(A[min] > A[j])
min=j;
aux=A[min];
A[min]=A[i];
A[i]=aux ;
}
}
void main ()
{
int A[largo],n;
do{
cout<<"Cantidad de numeros a ingresar: ";cin>>n;
if(n<=0||n>largo)
cout<<"Debe ingresar un valor > a 0 y < a "<<largo<<endl;
}while(n<=0||n>largo);

leeCadena(n,A);
seleccionsort(A,n);
muestraCadena(n,A);

}
2. ORDENAMIENTO POR INSERCIÓN DIRECTA

DESCRIPCIÓN.

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


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

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


complejidad cuadrático, junto con SelectionSort y BubbleSort.

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

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

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

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

ANÁLISIS DEL ALGORITMO.

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

Ventajas: 

• Fácil implementación. 
• Requerimientos mínimos de memoria. 
Desventajas: 

• Lento. 
• Realiza numerosas comparaciones. 

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

CODIFICACIÓN EN C++

#include<iostream>
#include"leearreglo.h"
using namespace std;
#define largo 50
void insercionDirecta(int A[],int n)
{

int i,j,v;

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


{
v = A[i];
j = i - 1;
while (j >= 0 && A[j] > v)
{
A[j + 1] = A[j];
j--;
}

A[j + 1] = v;
}
}

void main ()
{
int A[largo],n;
do{
cout<<"Cantidad de numeros a ingresar: ";cin>>n;
if(n<=0||n>largo)
cout<<"Debe ingresar un valor > a 0 y < a "<<largo<<endl;
}while(n<=0||n>largo);

leeCadena(n,A);
insercionDirecta(A,n);
muestraCadena(n,A);

}
3. MÉTODO DE  ORDENAMIENTO POR INSERCIÓN BINARIA

El método de ordenación por 'inserción binaria'' es una mejora del método de  inserción 
directa.   Para  lograr   esta   mejora   se   recurre   a   una  búsqueda   binaria   en  lugar   de  una 
búsqueda secuencial para insertar un elemento en la parte izquierda del arreglo, que ya 
se encuentra ordenado. El resto del procedimiento es similar al de inserción directa, es 
decir, se repite este mismo procedimiento desde el segundo término hasta el último 
elemento.  
 

ALGORITMO

INSERCION BINARIA (A, N)
{
 para (i=2 hasta N)
         {
           aux = A[i];
           izq=1;
           der=i­1;
           mientras (izq<=der)
                         {
                            m=[parte entera ((izq+der)/2)];
                            si (aux<A[M])
                               {
                                 der=m­1;
                                }
                            si no
                                  {
                                    izq=m+1;
                                   }
                         }
           j=i­1;
           mientras (j>=izq)
                         {
                           A[j+1]=A[j];
                           j=j­11;
                          }
          A[izq]=auz;
}
CODIFICACIÓN EN C++

#include<iostream>
#include"leearreglo.h"
using namespace std;
#define largo 50
void insercionBinaria(int A[],int n)
{
int i,j,aux,izq,der,m;
for(i=1;i<n;i++)
{
aux = A[i];
izq=0;
der=i-1;
while(izq<=der)
{
m=((izq+der)/2);
if (aux<A[m])
der=m-1;
else
izq=m+1;
}
j=i-1;
while(j>=izq)
{
A[j+1]=A[j];
j=j-1;
}
A[izq]=aux;
}
}

void main ()
{
int A[largo],n;
do{
cout<<"Cantidad de numeros a ingresar: ";cin>>n;
if(n<=0||n>largo)
cout<<"Debe ingresar un valor > a 0 y < a "<<largo<<endl;
}while(n<=0||n>largo);

leeCadena(n,A);
insercionBinaria(A,n);
muestraCadena(n,A);

}
4. ORDENAMIENTO POR EL MÉTODO DE SHELL

El método Shell es una versión mejorada del método de inserción directa. Este método 
también  se conoce con el nombre de inserción con incrementos  decrecientes. En el 
método de ordenación por inserción directa cada elemento se compara para su ubicación 
correcta en el arreglo, con los elementos que se encuentran en la parte izquierda del 
mismo. Si el elemento a insertar es más pequeño que el grupo de elementos que se 
encuentran a su izquierda, es necesario efectuar entonces varias comparaciones antes de 
su ubicación.

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

El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta 
dos observaciones:

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

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

El Shell sort lleva este nombre en honor a su inventor, Donald Shell, que lo publicó en 
1959. 
CODIFICACIÓN EN C++

#include<iostream>
#include"leearreglo.h"
using namespace std;
#define largo 50
void ordenShell(int A[],int n)
{

int i, j, inc, temp;

for(inc = 1 ; inc<n;inc=inc*3+1);

while (inc > 0)


{
for (i=inc; i < n; i++)
{
j = i;
temp = A[i];
while ((j >= inc) && (A[j-inc] > temp))
{
A[j] = A[j - inc];
j = j - inc;
}

A[j] = temp;
}

inc/= 2;
}
}

void main ()
{
int A[largo],n;
do{
cout<<"Cantidad de numeros a ingresar: ";cin>>n;
if(n<=0||n>largo)
cout<<"Debe ingresar un valor > a 0 y < a "<<largo<<endl;
}while(n<=0||n>largo);

leeCadena(n,A);
ordenShell(A,n);
muestraCadena(n,A);

}
ORDENAMIENTO QUICK SORT

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

Tiene   aparentemente   la   propiedad   de   trabajar   mejor   para   elementos   de   entrada 


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

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

Normalmente al inicio de la ordenación se escoge un elemento aproximadamente en la 
mitad del arreglo, así al empezar a ordenar, se debe llegar a que el arreglo este ordenado 
respecto al punto de división o la mitad del arreglo.

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

Los siguientes pasos son llamados recursivos con el propósito de efectuar la ordenación 
por partición al arreglo izquierdo y al arreglo derecho, que se obtienen de la primera 
fase. El tamaño de esos arreglos en promedio se reduce a la mitad.

Así se continúa hasta que el tamaño de los arreglos a ordenar es 1, es decir, todos los 
elementos ya están ordenados.

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

#include <iostream>
#define largo 100
#include"leearreglo.h"
using namespace std;
void quicksort(int A[],int izq, int der )
{
int i, j, x , aux;
i = izq;
j = der;
x = A[ (izq + der) /2 ];
do{
while( (A[i] < x) && (j <= der) )
{
i++;
}

while( (x < A[j]) && (j > izq) )


{
j--;
}

if( i <= j )
{
aux = A[i]; A[i] = A[j]; A[j] = aux;
i++; j--;
}

}while( i <= j );

if( izq < j )


quicksort( A, izq, j );
if( i < der )
quicksort( A, i, der );
}

void main ()
{
int A[largo],n;
do{
cout<<"Cantidad de numeros a ingresar: ";cin>>n;
if(n<=0||n>largo)
cout<<"Debe ingresar un valor > a 0 y < a "<<largo<<endl;
}while(n<=0||n>largo);
leeCadena(n,A);
quicksort(A,0,n-1);
muestraCadena(n,A);

}
ORDENAMIENTO HEAP SORT

El  ordenamiento   por   montículos  (Heap   sort)   es   un  algoritmo  de  ordenación  no 


recursivo, no estable, con complejidad computacional O(n log n).

Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un 
montículo  (heap), y luego extraer el nodo que queda como nodo raíz del montículo 
(cima)   en   sucesivas   iteraciones   obteniendo   el   conjunto   ordenado.   Basa   su 
funcionamiento   en   una   propiedad   de   los   montículos,   por   la   cual,   la   cima   contiene 
siempre el menor elemento (o el mayor, según se haya definido el montículo) de todos 
los almacenados en él.

El   significado   de   heap   en   ciencia   computacional   es   el   de   una   cola   de   prioridades 


(priority queue). Tiene las siguientes características:

Un heap es un arreglo de n posiciones ocupado por los elementos de la cola. 
(Nota:  se utiliza  un arreglo que inicia  en la posición 1 y no en cero, de tal 
manera que al implementarla en C se tienen n+1 posiciones en el arreglo.) 

Se mapea un árbol binario de tal manera en el arreglo que el nodo en la posición 
i es el padre de los nodos en las posiciones (2*i) y (2*i+1). 

El valor en un nodo es mayor o igual a los valores de sus hijos. Por consiguiente, 
el nodo padre tiene el mayor valor de todo su subárbol.

PROCEDIMIENTO

Heap Sort consiste esencialmente en:

• Convertir el arreglo en un heap 
• Construir   un   arreglo   ordenado   de   atrás   hacia   adelante   (mayor   a   menor) 
repitiendo los siguientes pasos: 
• Sacar el valor máximo en el heap (el de la posición 1) 
• Poner ese valor en el arreglo ordenado 
• Reconstruir el heap con un elemento menos
• Utilizar el mismo arreglo para el heap y el arreglo ordenado.
CODIFICACIÓN EN C++

#include <iostream>
#define max 100
using namespace std;

int main()
{
int A[max],j,item,temp,i,k,n;
cout<<"Ingresa la cantidad de elementos del arreglo: ";
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=i/2;
while(j>0 && A[j]<item)
{
A[i]=A[j];
i=j;
j=j/2;
}
A[i]=item;
}
temp=A[1];
A[1]=A[k];
A[k]=temp;
}
cout<<"El orden es:"<<endl;
for(i=1;i<=n;i++)
cout<<A[i] << endl;
return 0;
}
ANEXO

LIBRERÍA UTILIZADA EN LOS CÓDIGOS

ORDENACIÓN POR SELECCIÓN

ORDENACIÓN POR INSERCIÓN DIRECTA

ORDENACIÓN POR INSERCIÓN BINARIA

ORDENACIÓN SHELL SORT

ORDENACIÓN QUICK SORT

“leearreglo.h”

#include<iostream>
using namespace std;
void leeCadena(int cant,int n[])
{
int i;
for(i=0;i<cant;i++)
{
cout<<"Ingresa numero "<<i+1<<": ";
cin>>n[i];
}

void muestraCadena(int cant,int n[])


{
int i;
for(i=0;i<cant;i++)
{
cout<<n[i]<<endl;
}
}

También podría gustarte