¡Descarga Algoritmos de Ordenación y Búsqueda: Complejidad Computacional y Eficiencia y más Ejercicios en PDF de Programación C solo en Docsity!
Tema 8:
Algoritmos de ordenación y
búsqueda
Objetivos : en este tema se presentan algoritmos que permiten buscar un
elemento dentro de una colección y ordenar una colección en base a algún
criterio (el valor de un número, orden alfabético...). Ambas operaciones son
empleadas profusamente en computación, de ahí su gran importancia, y se
apoyan la una es la otra, por lo que las hemos agrupado bajo un mismo tema.
Índice
1 Introducción
La ordenación es una aplicación fundamental en computación. La mayoría de los datos
producidos por un programa están ordenados de alguna manera, y muchos de los cómputos
que tiene que realizar un programa son más eficientes si los datos sobre los que operan
están ordenados. Uno de los tipos de cómputo que más se benefician de operar sobre un
conjunto de datos ordenados es la búsqueda de un dato: encontrar el número de teléfono de
una persona en un listín telefónico es una tarea muy simple y rápida si conocemos su
nombre, ya que los listines telefónicos se encuentran ordenados alfabéticamente. Encontrar
a que usuario corresponde un número de teléfono dado, sin embargo, es una tarea
prácticamente inabordable. Valga esto a modo de ejemplo de cómo el disponer de una
colección de datos ordenados simplifica la búsqueda de información entre ellos, de ahí la
importancia de las tareas de ordenación y búsqueda y la relación que existe entre ellas.
Las operaciones de ordenación y búsqueda suelen clasificarse en dos tipos:
- Internas : todos los datos a procesar residen en la memoria principal.
- Externas : los otros procesos residen en un dispositivo de almacenamiento masivo,
de acceso lento. Su volumen es demasiado elevado para trasladarlos todos a la
memoria principal, lo cual fuerza realizar numerosos accesos al dispositivo de
almacenamiento masivo.
En este tema nos centraremos en las operaciones internas. Un factor clave en cualquier
algoritmo de búsqueda u ordenación es su complejidad computacional, y el cómo esta
depende del número de datos a procesar. Habitualmente, cuando nos enfrentamos una tarea
de ordenación o búsqueda con un ordenador el volumen de datos de entrada será enorme y
es importante contar con algoritmos que no degraden considerablemente su rendimiento
con el tamaño del conjunto de datos. Por ello, antes de abordar algoritmos de ordenación y
búsqueda realizaremos una pequeña introducción al cálculo de la complejidad
computacional de un algoritmo.
2 Complejidad computacional y algoritmos
Habitualmente, un mismo problema puede tener
numerosas soluciones que tienen distinta eficiencia
(rapidez de ejecución). Así, por ejemplo, un problema
tan fácil como el multiplicar dos números enteros es
resuelto mediante dos algoritmos diferentes en
Inglaterra y el resto de Europa. Otra forma mucho
más curiosa de realizar la multiplicación de los
números enteros es el método ruso; un método más
complejo que los anteriores y que requiere realizar un número de operaciones matemáticas
bastante superior, aunque obtiene el mismo resultado:
Cuando seleccionamos un algoritmo para resolver un determinado problema es importante
determinar los recursos computacionales necesarios (tiempo de computación y espacio de
almacenamiento en memoria) en función del volumen de datos a procesar. La eficiencia de
un algoritmo no puede medirse en unidades de tiempo, ya que esto obligaría a realizar
medidas empíricas sobre una implementación concreta, un compilador concreto y una
máquina concreta.
El cálculo de la eficiencia de un algoritmo se basa en contar el número de operaciones
elementales que realiza. Por operación elemental se entiende operación cuyo tiempo de
ejecución es constante y depende únicamente de la implementación como, por ejemplo,
sumas, restas, productos, divisiones, módulo, operaciones lógicas, operaciones de
comparación, etcétera. Estas operaciones no deben depender del volumen de datos
manejados por el algoritmo, y sólo nos interesa el número de operaciones, no cuánto
consume cada una de ellas. La diferencia en los tiempos de ejecución entre las distintas
operaciones quedan incluidos en la constante multiplicativa.
Para representar la eficiencia de un algoritmo suele emplearse la natación "del orden de"
(O (...)). Diremos que una función t (n) está en el orden de f (n) si existe una constante c y
un umbral n 0 tal es que:
∀ n ≥ n 0 t ( n )≤ c ⋅ f ( n )
Textualmente esto se representa por "t es del orden de f" (t=O (f)). Esta frase indica que si
t es el tiempo de la implementación de un algoritmo podemos considerar que dicho tiempo
está en el orden de f. Además, por el principio de invarianza, cualquier implementación de
dicho algoritmo también será de orden f. La notación t=O (f) suele usarse aunque f(n) sea
menor que cero para algún n, o incluso cuando no esté definida para algún valor de n; lo
importante es el comportamiento de f (n) para valores grandes de n.
2.1 Complejidad computacional de las estructuras básicas de
programación
En esta sección estudiaremos cuál es la complejidad computacional de las estructuras
básicas que permiten construir algoritmos.
2.1.1 Sentencias sencillas
Nos referimos a las sentencias de asignación, comparación, operaciones lógicas y
matemáticas. Este tipo de sentencias tiene un tiempo de ejecución constante que no
depende del tamaño del conjunto de datos de entrada, siendo su complejidad O (1).
2.1.2 Secuencia de sentencias
La complejidad de una serie de elementos de un programa es del orden de la suma de las
complejidades individuales; el caso de una secuencia de sentencias sencillas la
complejidad será: O (1)+ O (1)+...+ O (1)= k* O (1)= O (1).
2.1.3 Selección
La evaluación de la condición suele ser de O (1), complejidad a sumar con la mayor
complejidad computacional posible de las distintas ramas de ejecución, bien en la rama IF,
o bien en la rama ELSE. En decisiones múltiples (ELSE IF, SWITCH CASE), se tomará la
rama cuya complejidad computacional es superior.
2.1.4 Bucles
Los bucles son la estructura de control de flujo que suele determinar la complejidad
computacional del algoritmo, ya que en ellos se realiza un mayor número de operaciones.
En los bucles con contador podemos distinguir dos casos: que el tamaño del conjunto de
datos n forme parte de los límites del bucle o que no. Si la condición de salida del bucle es
independiente de n entonces la repetición sólo introduce una constante multiplicativa:
for (int i= 0; i < K; i++) { O (1)}
la complejidad será K*O(1) = O(1).
Cuando el número de iteraciones a realizar depende del tamaño de datos a procesar la
complejidad computacional del bucle incrementará con el tamaño de los datos de entrada:
for (int i= 0; i < n; i++) { O (1)}
la complejidad será n* O (1)= O (n).
for (int i= 0; i < n; i++) { for (int j= 0; j < n; j++) {
O (1)
En este caso tenemos un bucle interno de orden O (log n) que se ejecuta n veces, luego el
conjunto es de orden O (n log n).
2.2 Limitaciones del análisis O
El análisis O no es adecuado para pequeñas cantidades de datos, ya que las
simplificaciones que se realizan en el cálculo de la complejidad del algoritmo se apoya en
la suposición de que n es un número grande.
Las constantes grandes pueden entrar a juego en los algoritmos excesivamente complejos;
en esto también influye el hecho de que el análisis no tiene en cuenta que la constante
asociada a una operación simple, con un acceso memoria, es muy inferior a la constante
asociada a un acceso a disco.
Por último, el análisis supone que contamos con una memoria infinita y no mide el
impacto de este recurso en la eficiencia del algoritmo.
3 Algoritmos de búsqueda
Un problema de búsqueda puede enunciarse del siguiente modo: dado un conjunto de
elementos CB (Conjunto Búsqueda) de un cierto tipo determinar si un elemento ("dato")
se encuentra en el conjunto o no.
Existen diferentes algoritmos de búsqueda y la elección depende de la forma en que se
encuentren organizados los datos: si se encuentran ordenados o si se ignora su disposición
o se sabe que están al azar. También depende de si los datos a ordenar pueden ser
accedidos de modo aleatorio o deben ser accedidos de modo secuencial.
3.1 Búsqueda secuencial
Es el algoritmo de búsqueda más simple, menos eficiente y que menos precondiciones
requiere: no requiere conocimientos sobre el conjunto de búsqueda ni acceso aleatorio.
Consiste en comparar cada elemento del conjunto de búsqueda con el valor deseado hasta
que éste sea encontrado o hasta que se termine de leer el conjunto.
Supondremos que los datos están almacenados en un array y se asumirá acceso secuencial.
Se pueden considerar dos variantes del método: con y sin centinela.
3.1.1 Búsqueda sin centinela
El algoritmo simplemente recorre el array comparando cada elemento con el dato que se
está buscando:
*ejemplo8_1.c */
#include <stdlib.h> #include <stdio.h> #include <time.h>
#define TAM 100
void imprimeCB(int *CB) { int i; for(i = 0; i < TAM-1; i++) { printf( "%d, ", CB[i]); } printf( "%d\n", CB[i]); }
int main() { int CB[TAM]; int i, dato;
srand((unsigned int)time(NULL)); for(i = 0; i < TAM; i++) CB[i] = (int)(rand() % 100); imprimeCB(CB); dato = (int)(rand() % 100); printf("Dato a buscar %d\n",dato);
i=0; while ((CB[i]!=dato) && (i<TAM)) i++;
if (CB[i]==dato) printf("Posicion %d\n",i); else printf("Elemento no esta en el array"); }
La complejidad del algoritmo medida en número de iteraciones en el mejor caso será 1, y
se corresponderá con aquella situación en la cual el elemento a buscar está en la primera
posición del array. El peor caso la complejidad será TAM y sucederá cuando el elemento
printf("Dato a buscar %d\n",dato);
i=0; while (CB[i]!=dato) i++;
if (CB[i]==dato) printf("Posicion %d\n",i); else printf("Elemento no esta en el array"); }
Ahora sólo se realiza una suma y una única comparación (se ahorra una comparación y un
AND). El algoritmo es más eficiente.
3.2 Búsqueda binaria o dicotómica
Es un método muy eficiente, pero tiene varios prerrequisitos:
- El conjunto de búsqueda está ordenado.
- Se dispone de acceso aleatorio.
Este algoritmo compara el dato buscado con el elemento central. Según sea menor o mayor
se prosigue la búsqueda con el subconjunto anterior o posterior, respectivamente, al
elemento central, y así sucesivamente.
*ejemplo8_3.c */
#include <stdlib.h> #include <stdio.h> #include <time.h>
#define TAM 100
void imprimeCB(int *CB) { int i; for(i = 0; i < TAM-1; i++) { printf( "%d, ", CB[i]); } printf( "%d\n", CB[i]); }
int main() { int CB[TAM]; int ini=0,fin=TAM-1,mitad,dato,i;
srand((unsigned int)time(NULL));
for(i = 0; i < TAM; i++) CB[i] = (int)(rand() % 100); imprimeCB(CB); dato = (int)(rand() % 100); CB[i] = dato; printf("Dato a buscar %d\n",dato);
mitad=(ini+fin)/2; while ((ini<=fin)&&(CB[mitad]!=dato)) { if (dato < CB[mitad]) fin=mitad-1; else ini=mitad+1; mitad=(ini+fin)/2; }
if (dato==CB[mitad]) printf("Posicion %d\n", mitad); else printf("Elemento no esta en el array"); getch(); }
En el caso más favorable (el dato es el elemento mitad) se realiza 1 iteración. En el caso
más desfavorable, el número de iteraciones es el menor entero K que verifica 2 K^ >= TAM.
Esto es, el orden de complejidad es O (log 2 (TAM) ).
Veamos un ejemplo; tenemos que buscar el número 8 en la siguiente conjunto de datos:
1 2 2 2 4 4 5 6 6 9 (ini,fin) mitad
- (0 ,9) 4 1 2 2 2 4 4 5 6 6 9
- (5 ,9) 7 1 2 2 2 4 4 5 6 6 9
- (8 ,9) 8 1 2 2 2 4 4 5 6 6 9
- (9 ,9) 9 No se encontro.... (9 ,8)
Busquemos el mismo valor en otro conjunto de datos:
0 1 1 2 2 6 7 7 8 9 (ini,fin) mitad
- (0 ,9) 4 0 1 1 2 2 6 7 7 8 9
- (5 ,9) 7 0 1 1 2 2 6 7 7 8 9
- (8 ,9) 8 Posicion 8
Su nombre se debe a que el elemento cuyo valor es mayor sube a la posición final del
array, al igual que las burbujas de aire en un depósito suben a la parte superior. Para ello
debe realizar un recorrido paso a paso desde su posición inicial hasta la posición final del
array.
*ejemplo8_4.c */
#include <stdlib.h> #include <stdio.h> #include <time.h>
#define TAM 100
void imprimeCB(int *CB) { int i; for(i = 0; i < TAM-1; i++) { printf( "%d, ", CB[i]); } printf( "%d\n", CB[i]); }
int main() { int CB[TAM]; int e, i, auxiliar;
srand((unsigned int)time(NULL));
for(e = 0; e < TAM; e++) CB[e] = (int)(rand() % 100);
printf( "Antes de ordenar---------------------\n"); imprimeCB(CB);
for(e = 0; e < TAM; e++) for(i = 0; i < TAM-1-e; i++) if(CB[i] > CB[i+1]) { auxiliar = CB[i+1]; CB[i+1] = CB[i]; CB[i] = auxiliar; }
printf( "\nDespués de ordenar\n------------------\n"); imprimeCB(CB); }
Veamos un ejemplo:
La complejidad computacional de éste algoritmo O (TAM 2 ).
4.1.1 Burbuja mejorada
Existe una forma muy obvia para mejorar el algoritmo de la burbuja. Basta con tener en
cuenta la posibilidad de que el conjunto esté ordenado en algún paso intermedio. Si el
bucle interno no necesita realizar ningún intercambio en alguna pasada, el conjunto estará
ya ordenado.
*ejemplo8_5.c */
#include <stdlib.h> #include <stdio.h> #include <time.h>
#define TAM 100
void imprimeCB(int *CB) { int i; for(i = 0; i < TAM-1; i++) { printf( "%d, ", CB[i]); } printf( "%d\n", CB[i]); }
int main() { int CB[TAM]; int e, i, auxiliar,intercambio;
srand((unsigned int)time(NULL));
for(e = 0; e < TAM; e++) CB[e] = (int)(rand() % 100);
printf( "Antes de ordenar\n--------------\n"); imprimeCB(CB);
empieza por el menor elemento de la parte desordenada y lo intercambia con el que ocupa
su posición en la parte ordenada. Así, en la la primera iteración se busca el menor
elemento y se intercambia con el que ocupa la posición 0; en la segunda, se busca el menor
elemento entre la posición 1 y el final y se intercambia con el elemento en la posición 1.
De esta manera las dos primeras posiciones del array están ordenadas y contienen los dos
elementos menores dentro del array. Este proceso continúa hasta ordenar todos los
elementos del array.
*ejemplo8_6.c */
#include <stdlib.h> #include <stdio.h> #include <time.h>
#define TAM 100
void imprimeCB(int *CB) { int i; for(i = 0; i < TAM-1; i++) { printf( "%d, ", CB[i]); } printf( "%d\n", CB[i]); }
int main() { int CB[TAM]; int e,i,PosMenor,aux;
srand((unsigned int)time(NULL));
for(e = 0; e < TAM; e++) CB[e] = (int)(rand() % 100);
printf( "Antes de ordenar\n-----------------------\n"); imprimeCB(CB);
for (e=0; e<(TAM-1) ; e++) { PosMenor=e; for (i=e+1;i<TAM;i++) if (CB[i]<CB[PosMenor]) PosMenor=i;
aux=CB[e]; CB[e]=CB[PosMenor]; CB[PosMenor]=aux; }
printf( "\nDespués de ordenar\n--------------------\n"); imprimeCB(CB); }
En cada pasada se coloca un elemento en su lugar, y la variable e marca donde empezar la
búsqueda en la parte desordenada, que será secuencial si no tenemos más información. La
búsqueda del siguiente elemento menor comienza suponiendo que dicho elemento es e. Se
comprueba la hipótesis comparándolo con cada uno de los restantes. Si se encuentra uno
menor, se intercambia.
Veamos un ejemplo de la ejecución de éste algoritmo:
El número de comparaciones que realiza este algoritmo es independiente de la ordenación
inicial. El bucle interno hace TAM-1 comparaciones la primera vez, TAM-2 la segunda,...,
y 1 la última. El bucle externo hace TAM-1 búsquedas. El total de comparaciones es
(TAM 2 -TAM)/2. Por tanto el orden de complejidad es cuadrático ( O(TAM 2 ) ).
4.3 Método de inserción
Se utiliza un método similar al anterior, tomando un elemento de la parte no ordenada para
colocarlo en su lugar en la parte ordenada. El primer elemento del array (CB[0]) se
considerado ordenado (la lista inicial consta de un elemento). A continuación se inserta el
segundo elemento (CB[1]) en la posición correcta (delante o detrás de CB[0]) dependiendo
de que sea menor o mayor que CB[0]. Repetimos esta operación sucesivamente de tal
modo que se va colocando cada elemento en la posición correcta. El proceso se repetirá
TAM-1 veces.
Para colocar el dato en su lugar, se debe encontrar la posición que le corresponde en la
parte ordenada y hacerle un hueco de forma que se pueda insertar. Para encontrar la
posición se puede hacer una búsqueda secuencial desde el principio del conjunto hasta
