Método Shaker Sort
Este método es una optimización del ordenamiento para el intercambio directo (La burbuja) la idea
basica de este algoritmo consiste en mezclar las dos formas en que se pueda realizar la burbuja en
este algoritmo cada pasada tiene 2 pasadas en la primera pasada es de derecha a izquierda se
trasladan los elementos más pequeños hacia la izquierda del arreglo (almacenando la posición del
último elemento intercambiado) en la segunda pasada de izquierda a derecha se trasladan los
elementos más grandes hacia la derecha del arreglo almacenando en otra variable la posición del
ultimo elemento intercambiado. Las sucesivas pasadas trabajan con los componentes del arreglo
comprendidos entre las posiciones almacenadas en variables el algoritmo termina cuando en una
etapa no se producen intercambios o bien cuando el contenido de la variable que almacena a el
extremo izquierdo del arreglo es menor que el contenido en la variable almacenada en el extremo
derecho.
public void shaker_sort(Form forma, bool como)
{
int a, b, c, d, aux;
c = 1;
b = [Link]- 1;
d = [Link] – 1;
do
{
for ( a=d;a >=c; –a)
{
if (vec[a – 1] > vec[a])
{
aux = vec[a – 1];
vec[a – 1] = vec[a];
vec[a] = aux;
b = a;
}
}
c = b + 1;
for(a=c;a<d+1;++a)
{
if (vec[a – 1] > vec[a])
{
aux = vec[a – 1];
vec[a – 1] = vec[a];
vec[a] = aux;
b = a;
}
}
d = b – 1;
} while (c <= d);
if (como)
muestraN(forma, comp, interc);
else
muestraG(forma, comp, interc);
}
Método de Inserción Directa
Este método toma cada elemento del arreglo para ser ordenado y lo compara con los que se
encuentran en posiciones anteriores a la de el dentro del arreglo. Si resulta que el elemento con el
que se esta comparando es mayor que el elemento a ordenar, se detiene el proceso de
comparación pues se encontró que el elemento ya está ordenado se coloca en su posición (que es
la siguiente a al del ultimo numero con el que se comparo).
Peuso código
Este procedimiento recibe el arreglo de datos a ordenar A y altera las posiciones de sus elementos
hasta dejarlos ordenados de menor a mayor. N representa el numero de elementos que contiene
A.
Metodo QuickShort
Si bien el método de la burbuja era considerado como el peor método de ordenación simple o
menos eficiente, el método Quicksort basa su estrategia en la idea intuitiva de que es más fácil
ordenar una gran estructura de datos subdividiéndolas en otras más pequeñas introduciendo un
orden relativo entre ellas. En otras palabras, si dividimos el array a ordenar en dos subarrays de
forma que los elementos del subarray inferior sean más pequeños que los del subarray superior, y
aplicamos el método reiteradamente, al final tendremos el array inicial totalmente ordenado.
Existen además otros métodos conocidos, el de ordenación por montículo y el de shell.
using System;
using [Link];
using [Link];
using [Link];
namespace quicksort
{
class Class
{
static void Main()
{
int n;
[Link]("Metodo de Quick Sort");
[Link]("Cuantos longitud del vector: ");
n = [Link]([Link]());
llenar b = new llenar(n);
}
}
class llenar
{
int h;
int[] vector;
public llenar(int n)
{
h = n;
vector = new int[h];
for (int i = 0; i < h; i++)
{
[Link]("ingrese valor {0}: ", i + 1);
vector[i] = [Link]([Link]());
}
quicksort(vector, 0, h - 1);
mostrar();
}
private void quicksort(int[] vector, int primero, int ultimo)
{
int i, j, central;
double pivote;
central = (primero + ultimo) / 2;
pivote = vector[central];
i = primero;
j = ultimo;
do
{
while (vector[i] < pivote) i++;
while (vector[j] > pivote) j--;
if (i <= j)
{
int temp;
temp = vector[i];
vector[i] = vector[j];
vector[j] = temp;
i++;
j--;
}
} while (i <= j);
if (primero < j)
{
quicksort(vector, primero, j);
}
if (i < ultimo)
{
quicksort(vector, i, ultimo);
}
}
private void mostrar()
{
[Link]("Vector ordenados en forma ascendente");
for (int i = 0; i < h; i++)
{
[Link]("{0} ", vector[i]);
}
[Link]();
}
}
}
Al ejecutar el código tenemos lo siguiente:
Búsqueda Binaria
La operación de búsqueda puede ser mucho más eficiente si se sabe que los datos están
previamente ordenados. Basta considerar como ejemplo un diccionario en el que hacemos una
búsqueda gracias a la ordenación alfabética de las palabras. En otro caso, sería algo
completamente inutilizable.
La idea clave consiste en inspeccionar un elemento cualquiera, de índice m (normalmente en la
mitad), y compararlo con el argumento X. Los posibles casos son:
A(m)=X.- ha terminado la búsqueda y el índice buscando es m.
A(m)<X.- sabemos que todos los elementos a la izquierda de m son menores que X, y por
tanto pueden ser eliminada esta región de la zona de búsqueda y considerar solo la zona
derecha (desde m+1 hasta N).
A(m)>X.- sabemos que todos los elementos a la derecha de m son mayores que X, y
considerar para la búsqueda solo la zona izquierda (desde 1 hasta m-1).
La repetición de este proceso de forma iterativa constituye este algoritmo. Para ello, se
utilizan dos variables de índice, I y D, que marcan los extremos izquierdo y Derecho de la
zona de búsqueda considerara.
Búsqueda Secuencial
Es la solución más obvia y que se aplica cuando no hay ninguna información adicional acerca de
los datos buscados. Consiste en recorrer secuencialmente el vector hasta encontrar el dato
buscado. Siendo por tanto las condiciones de parada: A(i)=X se halló el elemento buscado ô i=N se
llegó al final del vector. Se debe comprobar después si la operación tuvo éxito, o simplemente se
llegó al final del vector.
