Métodos de Ordenamiento
Debido a que las estructuras de datos son utilizadas para almacenar información, para poder recuperar esa información de manera eficiente es deseable que aquella esté ordenada. Existen varios métodos para ordenar las diferentes estructuras de datos básicas.
En general los métodos de ordenamiento no son utilizados con frecuencia, en algunos casos sólo una vez. Hay métodos muy simples de implementar que son útiles en los casos en dónde el número de elementos a ordenar no es muy grande (ej, menos de 500 elementos). Por otro lado hay métodos sofisticados, más difíciles de implementar pero que son más eficientes en cuestión de tiempo de ejecución.
Los métodos sencillos por lo general requieren de aproximadamente n x n pasos para ordenar n elementos.
Los métodos simples son: insertion sort (o por inserción directa) selection sort, bubble sort, y shellsort, en dónde el último es una extensón al insertion sort, siendo más rápido. Los métodos más complejos son el quick-sort, el heap sort, radix y address-calculation sort. 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.
Método de Burbuja:
La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. 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
#include<stdio.h>
#include<conio.h>
int a[3]={3,2,1};
int i,j,aux,n=3;
void main(){
clrscr();
for(i=0;i<=n;i++){
for(j=0;j<n-1;j++){
if(a[j]>a[j+1]){
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
for(i=0;i<3;i++)
{
printf("%d",a);
}
getch();
}
Método de Selección:
El ordenamiento por selección (Selection Sort en inglés) es un algoritmo de ordenamiento que requiere Ooperaciones para ordenar una lista de n elementos.
Su funcionamiento es el siguiente:
-
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
De esta manera se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:
#include<stdio.h>
#include<conio.h>
int x[4]={1,4,8,6};
int n=4,j=0,i=0;
int temp=0,minimo=0;
void main(){
clrscr();
for(i=0;i<n-1;i++)
{
minimo=i;
for(j=i+1;j<n;j++)
{
if(x[minimo] > x[j])
{
minimo=j;
}
}
temp=x[minimo];
x[minimo]=x;
x=temp;
}
for(i=0;i<n;i++)
{
printf("%d",x);
}
getch();
}
Método de Shell:
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.
#include<stdio.h>
#include<conio.h>
int a[5];
int n=5;
void main()
{
int inter=(n/2),i=0,j=0,k=0,aux;
clrscr();
for (i=0; i<5; i++)
{
printf("INSERTA UN VALOR DEL INDICE %d", i);
scanf("%d",& a);
}
while(inter>0){
for(i=inter;i<n;i++)
{
j=i-inter;
while(j>=0) {
k=j+inter;
if(a[j]<=a[k]){
j--;
}
else{
aux=a[j];
a[j]=a[k];
a[k]=aux;
j=j-inter;
}
}
}
inter=inter/2;
}
for(i=0;i<5;i++)
{
printf("%d n",a);
getch();
}
}
Método de Inserción:
nicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Después, cuando hay k elementos ordenados de menor a mayor, se toma el elemento k+1 y se compara con todos los elementos ya ordenados, deteniéndose cuando se encuentra un elemento menor (todos los elementos mayores han sido desplazados una posición a la derecha) o cuando ya no se encuentran elementos (todos los elementos fueron desplazados y este es el más pequeño). En este punto se inserta el elemento k+1 debiendo desplazarse los demás elementos.
#include<stdio.h>
#include<conio.h>
int a[4]={4,1,7,2};
int n=4;
int i,j,aux;
void main(){
clrscr();
for(i=1;i<n;i++)
{
j=i;
aux=a;
while(j>0 && aux<a[j-1])
{
a[j]=a[j-1];
j--;
}
a[j]=aux;
}
for(i=0;i<4;i++)
{
printf("%d",a);
}
getch();
}
Método de Quick Sort:
l método Quick Sort es actualmente el mas eficiente y veloz de los método de ordenación interna. Es tambien conocido con el nombre del método rápido y de ordenamento por partición.
Este método es una mejora sustancial del método de intercambio directo y recibe el nombre de Quick Sort, por la velocidad con la que ordena los elementos del arreglo.
Quicksort es un algoritmo basado en la técnica de divide y vencerás, que permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n.
Quicksort es actualmente el más eficiente y veloz de los métodos de ordenación interna.
Este método fue creado por el científico británico Charles Antony Richard Hoare, tambien conocido como Tony Hoare en 1960, su algoritmo Quicksort es el algoritmo de ordenamiento más ampliamente utilizado en el mundo.
AHORA APLICANDO EN C++:
#include<iostream>
#include<math.h>
using namespace std;
int i,A[10],r,axu,n,menor,j,k,a,inc,izquierda,derecha;
float leer(),ordenar(),ver(),Seleccion(),Burbuja(),ordenar1(),Insercion(),ordenar2(),Shell(),QuickSort(),ordenar3(int A[],int n),ordenar4(int A[],int izquierda,int derecha);
int main(){
int opcion;
do{
cout<<"**************Prueba 10**************\n";
cout<<"1)Burbuja\n";
cout<<"2)Seleccion\n";
cout<<"3)Insercion\n";
cout<<"4)Shell\n";
cout<<"5)Quick Sort\n";
cout<<endl;
cout<<"Eliga Opcion\n";
cin>>opcion;
if(opcion>0,opcion<6){
switch (opcion){
case 1:{
Burbuja();
break;
}
case 2:{
Seleccion();
break;
}
case 3:{
Insercion();
break;
}
case 4:{
Shell();
break;
}
case 5:{
QuickSort();
break;
}
}
}else
cout<<"Opcion no existente\n";
cout<<endl;
cout<<endl;
}while (opcion!=0);
system("pause");
return(0);
}
float Burbuja(){
cout<<"*******Metodo Burbuja*******\n";
int opcion1;
cout<<"1)Leer\n";
cout<<"1)Oredenar\n";
cout<<"2)Ver\n";
cout<<endl;
cin>>opcion1;
if(opcion1>0,opcion1<4){
switch (opcion1){
case 1:{
leer();
break;
}
case 2:{
ordenar();
break;
}
case 3:{
ver();
break;
}
}
}
}
float leer(){
cout<<endl;
cout<<"*******Leer Vectores*******\n";
cout<<endl;
cout<<"Total= ";cin>>n;cout<<endl;
i=1;
cout<<"Vector[]\n";
while(i<=n){
cout<<"Vector["<<i<<"]= ";
cin>>A[i];
i=i+1;
}cout<<endl;
}
float ordenar(){
cout<<endl;
cout<<"*******Ordenamiento*******\n";
cout<<endl;
for(r=1;r<=n-1;r++){
for(i=1;i<=n;i++){
if(A[i]>A[i+1]){
axu=A[i];
A[i]=A[i+1];
A[i+1]=axu;
}
}
}
}
float ver(){
cout<<endl;
cout<<"*******Mirar Vectores*******\n";
cout<<endl;
i=1;
cout<<"Vector[]\n";
while(i<=n){
cout<<"Vector["<<i<<"]= ";
cout<<A[i];
i=i+1;
cout<<endl;
}
cout<<"#vueltas: "<<r<<endl;
cout<<endl;
}
float Seleccion(){
cout<<"*******Metodo Seleccion*******\n";
int opcion2;
cout<<"1)Oredenar\n";
cout<<"2)Ver\n";
cout<<endl;
cin>>opcion2;
if(opcion2>0,opcion2<3){
switch (opcion2){
case 1:{
ordenar1();
break;
}
case 2:{
ver();
break;
}
}
}
}
float ordenar1(){
for(i=1;i<=n;i++){
menor=A[i];
k=i;
for(j=1;j<=n;j++){
if(A[j]<menor){
menor=A[j];
k=j;
}
}A[k]=A[i];
A[i]=menor;
}
}
float Insercion(){
cout<<"*******Metodo Insercion*******\n";
int opcion3;
cout<<"1)Oredenar\n";
cout<<"2)Ver\n";
cout<<endl;
cin>>opcion3;
if(opcion3>0,opcion3<3){
switch (opcion3){
case 1:{
ordenar2();
break;
}
case 2:{
ver();
break;
}
}
}
}
float ordenar2(){
for (i=1; i<n; i++){
a=A[i];
j=i - 1;
while ( (A[j] >a) && (j >= 0) ){
A[j+1] = A[j];
j--;
A[j+1] = a;
}
}
}
float Shell(){
cout<<"*******Metodo Shell*******\n";
int opcion4;
cout<<"1)Oredenar\n";
cout<<"2)Ver\n";
cout<<endl;
cin>>opcion4;
if(opcion4>0,opcion4<3){
switch (opcion4){
case 1:{
ordenar3(A,n);
break;
}
case 2:{
ver();
break;
}
}
}
}
float ordenar3(int A[],int n){
int i, j, inc,axu;
for(inc=1 ; inc>0;){
for (i=inc;i=inc;A[j-inc]>axu){
A[j] = A[j-inc];
j = j-inc;
}A[j] = axu;
}inc/= 2;
}
float QuickSort(){
cout<<"*******Metodo Quick Sort*******\n";
int opcion5;
cout<<"1)Oredenar\n";
cout<<"2)Ver\n";
cout<<endl;
cin>>opcion5;
if(opcion5>0,opcion5<3){
switch (opcion5){
case 1:{
ordenar4(A,izquierda,derecha);
break;
}
case 2:{
ver();
break;
}
}
}
}
float ordenar4(int A[],int izquierda,int derecha){
int i,j,x,axu;
i=izquierda;
j=derecha;
x=A[(izquierda+derecha)/2];
do{
while((A[i]<x) && (j<=derecha)){
i++;
}
while((x<A[j]) && (j>izquierda)){
j--;
}
if( i<= j){
axu=A[i];
A[i]=A[j];
A[j]=axu;
i++;
j--;
}
}while( i <= j );
if( izquierda < j ){
ordenar4(A,izquierda,j);
}
if( i < derecha ){
ordenar4(A,i,derecha);
}
}fin algoritmo
