Está en la página 1de 15

ORDENACIÓN

Y
BÚSQUEDA

UNIDAD I
Algoritmos de ordenación
• Su finalidad es organizar ciertos datos
(normalmente arreglos o archivos) en un
orden creciente o decreciente mediante una
regla prefijada (numérica, alfabética...).
Tipos de ordenación
• Ordenación interna: Los datos se encuentran en
memoria (ya sean arreglos, listas, etc.), y son de
acceso aleatorio o directo (se puede acceder a un
determinado campo sin pasar por los anteriores).

• Ordenación externa: Los datos están en un


dispositivo de almacenamiento externo (archivos),
y su ordenación es más lenta que la interna.
Métodos de ordenación
Burbuja
• Consiste en comparar pares de elementos
adyacentes e intercambiarlos entre sí hasta
que estén todos ordenados.
void ordenarBurbuja(int tamArr, int arr[])
{
int index = 0;
int i, j;

Métodos de ordenación: Burbuja


int aux = 0;
int ordenado = 0; //Falso
while((index <= tamArr-1) && (ordenado == 0))
{ printf("%dma Pasada\n", index+1);
ordenado = 1; //verdadero
for(j=tamArr-1; j >0 ; j--)
{
if(arr[j-1] > arr[j])
{
aux = arr[j-1];
arr[j-1] = arr[j];
arr[j] = aux;
ordenado = 0; //falso
}
for(i=0; i < TAM_MAX; i++)
{
printf("%d - ", arr[i]);
}
printf("\n");
}
index ++;
printf("\n");
}
}
Métodos de ordenación
Inserción
• Consiste en considerar los elementos como
sublistas ordenada de elementos e ir
insertando elementos en el lugar adecuado
para que la sublista no pierda el orden.
• La sublista ordenada se va haciendo cada
vez mayor, de modo que al final la lista
entera queda ordenada.
void ordenarInsercion(int tamArr, int arr[])
{ int i, j;
int aux = 0;
int k = 0;

Métodos de ordenación: Inserción


for(i = 1; i < TAM_MAX; i++)
{
aux = arr[i];
k = i-1;
printf("%dma Pasada\n", i);
while (aux < arr[k] && k > 0)
{
arr[k+1] = arr[k];
k--;
}
if (arr[k] <= aux)
{
arr[k+1] = aux;
}
else
{
arr[k+1] = arr[k];
arr[k] = aux;
}
for(j=0; j < TAM_MAX; j++)
{
printf("%d - ", arr[j]);
}
printf("\n");
}
}
Métodos de ordenación
Shell
• Consiste en comparar a cada elemento con el que
está a un cierto número de lugares (llamado salto)
a su izquierda.
• Este salto es constante, y su valor inicial es N/2.
• Se van dando pasadas hasta que en una pasada no
se intercambie ningún elemento de sitio.
• Entonces el salto se reduce a la mitad, y se
vuelven a dar pasadas hasta que no se intercambie
ningún elemento, y así sucesivamente hasta que el
salto vale 1.
void ordenarShell(int tamArr, int arr[])
{
int tamIntervalo = 0; int cont = 1; int j, i, k; int aux = 0;
int ordenado = 0; //Falso
tamIntervalo = tamArr + 1;
while(tamIntervalo > 1)
{ printf("%dma Pasada\n", cont);

Métodos de ordenación: Shell tamIntervalo = tamIntervalo / 2;


for (j = tamIntervalo + 1; j < TAM_MAX; j++)
{
aux = arr [j];
i = j - tamIntervalo;
ordenado = 0; //Falso
while (i >= 0 && ordenado == 0)
{
if (aux < arr[i])
{
arr[i+tamIntervalo] = arr[i];
i = i - tamIntervalo;
}
else
{
ordenado = 1; //Verdadero;
}
}
arr[tamIntervalo + i] = aux;
}
cont++;
mostrarArreglo( TAM_MAX, arr);
}
}
Algoritmos de Búsqueda
• Tienen por objeto la localización de un
elemento dentro de la estructura de datos.

• Determinar si una estructura de datos


contiene un valor que coincide con algún
valor clave buscado.
Métodos de Búsqueda
Lineal
• Consiste en recorrer el arreglo elemento a
elemento e ir comparando con el valor buscado
(clave).
• Se empieza con la primera casilla del arreglo y se
observa una casilla tras otra hasta que se encuentra
el elemento buscado o se han visto todas las
casillas.
• El resultado de la búsqueda es un solo valor, y
será la posición del elemento buscado o cero.
int buscarSecuencial (int tamArr, int arr[], int clave)
{
Métodos de búsqueda: Lineal
int i;
int encontrado = 0; //Falso
int posicion = -1;
for (i=0; i < tamArr; i++)
{
if (arr[i]==clave)
{
encontrado = 1; //Verdadero
posicion = i;
break;
}
}
return posicion;
}
Métodos de Búsqueda
Binaria
• La búsqueda binaria es el método más eficiente para
encontrar elementos en un arreglo ordenado.
• El proceso comienza comparando el elemento central del
arreglo con el valor buscado. Si ambos coinciden finaliza
la búsqueda. Si no ocurre así, el elemento buscado será
mayor o menor en sentido estricto que el central del
arreglo. Si el elemento buscado es mayor se procede a
hacer búsqueda binaria en el subarreglo superior, si el
elemento buscado es menor que el contenido de la casilla
central, se procede a hacer búsqueda binaria en el
subarreglo inferior.
int buscarBinaria (int tamArr, int arr[], int clave)
{
int i; int bajo=0; int alto=tamArr-1;
int central=((bajo+alto)/2); int posicion = -1;

Métodos de búsqueda: Binaria


while ((bajo<=alto)&&(arr[central]!= clave))
{
if (clave < arr[central])
{
alto=central-1;
}
else
{
bajo=central+1;
}
central=((bajo+alto)/2);
}
if (clave == arr[central])
{
posicion = central;
}
return posicion;
}
Enlaces consultados
• http://mx.geocities.com/estructuras_informacion/paginas/
mordena.html
• http://www.cs.buap.mx/~titab/files/
Algoritmos_de_ordenacion.doc
• http://www.mailxmail.com/curso/informatica/programacionestru
• http://www.emagister.com/cursos-gratis/frame.cfm?id_centro
=27422070033149505256526748524548&id_curso
=53639020050250574951495356664570&id_segmento=3&
id_categ=557&url_frame=http://www2.ing.puc.cl/iic1102/
clases.htm