TARQUI BORDA
RIK RUDIER
ING ELECTRONICA
metodos de ordenamiento en c++
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.
La eficiencia de los algoritmos se mide por el número de comparaciones e intercambios que tienen que hacer, es decir, se toma n como el número de elementos que tiene el arreglo a ordenar y se dice que un algoritmo realiza O(n2) comparaciones cuando compara n veces los n elementos, n x n = n2.
ORDENAMIENTO POR SELECCION
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
//ORDENAMIENTO POR SELECCION
#include<iostream>
#include <math.h>
using namespace std;
void Seleccion(int [] , int );
void Imprimir(int [] , int );
int main()
{
int n;
cout<<"Cunatos elementos va a ingresar "<<endl;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
{
cout<<"Ingrese el numero "<<(i+1)<<" del arreglo"<<endl;
cin>>a[i];
}
Seleccion(a , n);
Imprimir(a , n);
}
void Seleccion(int a[] , int n)
{
//Variables a utilizar
int k , menor , i , j;
for(i=0;i<n;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;
}
}
void Imprimir(int a[] , int n)
{
cout<<"Numeros Ordenados de Menor a Mayor"<<endl;
for(int i=0;i<n;i++)
cout<<"[ "<<a[i]<<" ]";
}
//TARQUI BORDA RIK
ORDENAMIENTO 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.
//METODO BURBUJA
#include<iostream>
#include<math.h>
using namespace std ;
int main(){
int n,aux;
cout<<"Ingrese la cantidad de numeros :";
cin>>n;
int V[n];
for(int i=0;i<n;i++){
cout<<"\n Numero "<<i+1<<" = ";
cin>>V[i];
}
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(V[j]<V[i]){
aux=V[i];
V[i]=V[j];
V[j]=aux;
}
}
}
cout<<"ELEMENTOS ORDENADOS EN FORMA ASCENDENTE"<<endl;
for(int i=0;i<n;i++){
cout<<V[i]<<endl;
}
cout<<"ELEMENTOS ORDENADOS EN FORMA DESENDENTE"<<endl;
for(int i=(n-1);i>=0;i--){
cout<<V[i]<<endl;
}
return 0;
}
//tarqui borda rr
ORDENAMIENTO SHELL
El ordenamiento Shell (Shell sort en inglés) es un algoritmo de ordenamiento. El método se denomina Shell en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso. Un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n). Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. 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.
//ordenamiento por shell
#include<iostream>
#include<math.h>
using namespace std;
void Imprimir(int [] , int n);
void Shell(int [] , int n);
int main()
{
int total;
cout<<"Cunatos numeros tiene el arreglo"<<endl;
cin>>total;
int num[total];
for(int i=0;i<total;i++)
{
cout<<"Ingrese el numero para la posicion [ "<<(i+1)<<" ] del arreglo"<<endl;
cin>>num[i];
}
Shell(num,total);
}
void Shell(int a[] , int n)
{
int ints,i,aux;
bool band;
ints=n;
while(ints>1)
{
ints=(ints/2);
band=true;
while(band==true)
{
band=false;
i=0;
while((i+ints)<=n)
{
if(a[i]>a[i+ints])
{
aux=a[i];
a[i]=a[i+ints];
a[i+ints]=aux;
band=true;
}
i++;
Imprimir(a,n);
}
}
}
}
void Imprimir(int a[] , int n)
{
cout<<"Numeros del arreglo ordenandos de Menor a Mayor"<<endl;
for(int i=0;i<n;i++)
cout<<"[ "<<a[i]<<" ]";
}
Ordenamiento: QuickSort
Es un algoritmo como su nombre lo dice rápido pues es el mas rápido de los algoritmos de ordenación, ya que hace menos comparaciones.
- Usa la tecnica Divide y Venceras, la cual divide el arreglo en partes mas pequeñas, usando la recursividad.
- Su tiempo de ejecución promedio es O(n¨log2n). .
- Su tiempo de ejecucion en el pero caso es de O(n^2).
Para este algoritmo el pivote usado es el de posición (primero+ultimo)/2
//ORDENAMIENTO QUICKSORTT
#include<iostream>
#define MAX 1000
using namespace std;
void QuickSort(int [] , int );
void Imprimir(int [] , int);
int main()
{
int n ;
cout<<"Ingrese el total de numeros"<<endl;
cin>>n;
int a[n];
for(int i=0;i<n;i++){
cout<<"Ingresa el elemento numero "<<i+1<<" : "<<endl;
cin>>a[i];
}
QuickSort(a,n);
Imprimir(a,n);
}
void QuickSort(int a[] , int n)
{
int tope, ini, fin , pos;
int may[MAX],menor[MAX];
tope=0;
menor[tope]=0;
may[tope]=n-1;
while(tope>=0)
{
ini = menor[tope];
fin = may[tope];
tope--;
int izq,der,aux;
bool band;
izq=ini;
der=fin;
pos=ini;
band=true;
while(band==true)
{
while((a[pos]<a[der]) && ( pos!=der ))
der--;
if(pos==der)
band=false;
else
{
aux=a[pos];
a[pos]=a[der];
a[der]=aux;
pos=der;
}
while((a[pos]>a[izq]) && ( pos!=izq ))
izq++;
if(pos==izq)
band=false;
else
{
aux=a[pos];
a[pos]=a[izq];
a[izq]=aux;
pos=izq;
}
}
if(ini<=(pos-1))
{
tope++;
menor[tope]=ini;
may[tope]=pos-1;
}
if(fin>=(pos+1))
{
tope++;
menor[tope]=pos+1;
may[tope]=fin;
}
}
}
void Imprimir(int a[] , int n){
cout<<"Elementos Ordenados"<<endl;
for(int i =0 ;i<n;i++){
cout<<"["<<a[i]<<"]";
}
}
ORDENAMIENTO POR INSERCION
El ordenamiento por inserción (insertion sort en inglés) es una manera muy natural de ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria. Requiere O(n²) operaciones para ordenar una lista de n elementos.
Inicialmente 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.
//ordenamiento por insercion
#include<iostream>
#include<math.h>
using namespace std;
void Imprimir(int a[] , int n)
{
cout<<"Numeros Ordenados de Menor a Mayor"<<endl;
for(int i=0;i<n;i++)
cout<<"[ "<<a[i]<<" ]";
}
void Insercion(int a[] , int n)
{
int i,k,aux;
for(i=0;i<=n-1;i++)
{
aux=a[i];
k=i-1;
while((k>=0) && (aux<a[k]))
{
a[k+1]=a[k];
k=k-1;
}
a[k+1]=aux;
}
}
int main()
{
int n;
cout<<"Numero de elementos del arreglo"<<endl;
cin>>n;
int num[n];
for(int i=0;i<n;i++)
{
cout<<"Ingrese el numero "<<(i+1)<<endl;
cin>>num[i];
}
Insercion(num,n);
Imprimir(num,n);
return 0;
}
