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
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
o ORDENACIÓN HEAP SORT
 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 50void 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);muestraCade
na(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 n1 veces. El ciclo interno se
ejecuta como máximo una vez en la primera iteración, 2 veces en la segunda, 3 veces en la tercera, etc.

Ventajas:

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 50void 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=i1; mientras (izq<=der)
 { m=[parte entera ((izq+der)/2)]; si (aux<A[M])
 { der=m1; }
 si no
 { izq=m+1; }
 } j=i1; mientras (j>=izq)
 { A[j+1]=A[j]; j=j11;
 } A[izq]=auz; }
CODIFICACIÓN EN C++

#include<iostream> #include"leearreglo.h"using namespace

std;#define largo 50void 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:

El ordenamiento por inserción es eficiente si la entrada está "casi ordenada". 
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 50void 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; }}