ORDENAMIENTO Y BÚSQUEDA Los computadores se emplean frecuentemente para almacenar y recuperar grandes volúmenes de datos. Con su velocidad y facilidad de acceso, los computadores aventajan a otros medios de almacenamiento como el papel y las microfichas. Es importante estudiar la forma en que los computadores pueden almacenar los datos, de modo que su recuperación (búsqueda) sea rápida. Para lograr esto, y puesto que usualmente los usuarios requieren que los datos recuperados cuenten con algún orden particular, también es importante estudiar algoritmos para ordenar los datos almacenados. En todos los ejemplos se supondrá que existe un vector que contiene N datos. Para el caso de la búsqueda, el problema consiste en averiguar si un determinado dato está o no en el vector, y si es así, queremos saber su posición. Para el caso del ordenamiento, el problema consiste en ordenar el vector en forma ascendente (de menor a mayor). Si se quisiera trabajar con ordenamiento descendente los cambios serían mínimos. En esta sección estudiaremos varios algoritmos de búsqueda y ordenamiento que difieren entre sí en cuanto a su complejidad y eficiencia. Búsqueda Lineal Algoritmo: Recorrer el vector de inicio a fin, comparando el dato buscado con cada elemento del arreglo. Implementación: Mediante una función que implemente el algoritmo descrito. La función retornará la posición en que se encontró el dato, o bien la cantidad de elementos en el vector en el caso en que no se encuentre (esto sería un subíndice inválido). * Funcion que realiza una busqueda lineal de un valor entero en un vector * de enteros. La funcion recibe como parametros el vector, la cantidad de * elementos que hay en el vector (N) y el valor entero que se busca. * Si se encuentra el valor entonces se devuelve la posicion de este, sino * se devuelve la cantidad de elementos del vector. int BuscarLinealmente(int Numeros[], int N, int NumeroBuscado) { /* Inicializar el indice para recorrer el vector de numeros */ int i = 0; /* Recorrer el vector mientras no se llegue a su fin y no se encuentre el numero buscado */ while ((i < N) && (NumeroBuscado!= Numeros[i])) i++; /* Retornar la posicion del numero o la cantidad de elementos */ return(i); Ejemplo: Búsqueda lineal en vector de enteros
* Ejemplo: Busqueda lineal en un vector de enteros. #include <stdio.h> /* Para usar fscanf, FILE, fopen, fclose. */ #include <stdlib.h> #define MAX_N 50 /* Para la definicion del vector */ * Funcion que realiza una busqueda lineal de un valor entero en un vector * de enteros. La funcion recibe como parametros el vector, la cantidad de * elementos que hay en el vector (N) y el valor entero a buscar. * Si se encuentra el valor entonces se devuelve la posicion de este, sino * se devuelve la cantidad de elementos del vector. int BuscarLinealmente(int Numeros[], int N, int NumeroBuscado) { /* Inicializar el indice para recorrer el vector de numeros */ int i = 0; /* Recorrer el vector mientras no se llegue a su fin y no se encuentre el numero buscado */ while ((i < N) && (NumeroBuscado!= Numeros[i])) i++; /* Retornar la posicion del numero o la cantidad de elementos */ return(i); * Funcion para leer un vector de numeros enteros desde un archivo. El * nombre del archivo se recibe como argumento, junto con el nombre del * vector donde se guardaran los valores. En el archivo de entrada el * primer valor indica el numero de elementos que vienen a continuacion. * La funcion retorna la cantidad de valores leidos y guardados. int LeerVector(char archivo[], int Numeros[]) { FILE *fh; int i, Cant; printf("leyendo datos de entrada\n"); /* Abrir el archivo pasado por la linea de comandos */ fh = fopen(archivo, "r"); if (fh == NULL) { printf("error abriendo el archivo: %s\n", archivo); /* Leer la cantidad de elementos del vector desde el archivo */ fscanf(fh, "%d", &Cant); /* Leer los numeros desde el archivo */ for (i = 0; i < Cant; i++) fscanf(fh, "%d", &Numeros[i]); /* fscanf requiere puntero: & */ /* Cerrar el archivo */ fclose(fh); return(cant);
* Funcion para imprimir por pantalla el contenido de un vector de enteros * de 'N' elementos. void MostrarVector(int Numeros[], int N) { int i; printf("el vector de %d enteros es:\n", N); for (i = 0; i < N; i++) printf("%4d", Numeros[i]); * Programa para demostrar la busqueda lineal en un vector de enteros. * Primero se lee un vector de numeros enteros desde un archivo y se le * muestra al usuario. Luego se solicita a este que entre un numero y se * busca en el vector. Si no se encuentra el numero se le indica y si se * encuentra se imprime posicion que ocupa dentro del vector de enteros. main(int argc, char *argv[]) { int Numeros[MAX_N]; int NumElementos; int n; int Posicion; /* Verifica que el usuario haya escrito el nombre del archivo */ if (argc!= 2) { printf("uso: %s archivo\n", argv[0]); /* Leer un vector de enteros desde el archivo indicado */ NumElementos = LeerVector(argv[1], Numeros); /* Mostrar el vector */ MostrarVector(Numeros, NumElementos); /* Solicitar al usuario un numero a buscar */ printf("\ningrese un numero entero: "); scanf("%d", &n); /* scanf requiere puntero: & */ /* Buscar el numero en el vector */ Posicion = BuscarLinealmente(Numeros, NumElementos, n); if (Posicion == NumElementos) printf("\nel %d no esta en el vector.\n", n); else printf("\nel %d esta en la posicion %d.\n", n, Posicion); Archivo de entrada 10 3-5 20 0 11 4 2 9-1 90
Ejemplo de ejecución C:\>blineal entrada.txt Leyendo datos de entrada El vector de 10 enteros es: 3-5 20 0 11 4 2 9-1 90 Ingrese un numero entero: 5 El 5 no esta en el vector. C:\>blineal entrada.txt Leyendo datos de entrada El vector de 10 enteros es: 3-5 20 0 11 4 2 9-1 90 Ingrese un numero entero: 11 El 11 esta en la posicion 4. Ordenamiento por Selección Algoritmo recursivo escogiendo el mayor: Si el vector tiene un único elemento no se hace nada. En caso contrario, se elige el mayor de los elementos y se intercambia por el último (posición N-1). De esta forma, el último elemento estará en su posición correcta. Luego se ordena el subvector que tiene N-1 datos. * Funcion recursiva que ordena un vector de enteros por seleccion. * Si el vector tiene un solo elemento no se hace nada. De lo contrario, * se elige el mayor de los elementos y se intercambia por el ultimo del * vector (posicion N - 1). Luego se ordena el vector con N - 1 datos. void OrdenarPorSeleccionRecursivo(int Numeros[], int N) { int aux, i, PosMayor; if (N > 1) { /* Elige el mayor */ PosMayor = 0; /* Supone que el mayor es el primero */ for (i=1; i<n; i++) if (Numeros[i] > Numeros[PosMayor]) PosMayor = i; /* Se lleva a cabo el intercambio */ aux = Numeros[N - 1]; Numeros[N - 1] = Numeros[PosMayor]; Numeros[PosMayor] = aux; /* Llamado recursivo a funcion con el subvector de N-1 elementos */ OrdenarPorSeleccionRecursivo(Numeros, N - 1);
* Ejemplo: Ordenamiento por seleccion de forma recursiva seleccionando el * mayor elemento. #include <stdio.h> /* Para usar fscanf, FILE, fopen, fclose. */ #include <stdlib.h> #define MAX_N 50 /* Para la definicion del vector */ * Funcion recursiva que ordena un vector de enteros por seleccion. * Si el vector tiene un solo elemento no se hace nada. De lo contrario, * se elige el mayor de los elementos y se intercambia por el ultimo del * vector (posicion N - 1). Luego se ordena el vector con N - 1 datos. void OrdenarPorSeleccionRecursivo(int Numeros[], int N) { int i, PosMayor, aux; if (N > 1) { /* Busca el mayor elemento */ PosMayor = 0; /* Supone que el mayor es el primero */ for (i=1; i<n; i++) if (Numeros[i] > Numeros[PosMayor]) PosMayor = i; /* Se lleva a cabo el intercambio */ aux = Numeros[N - 1]; Numeros[N - 1] = Numeros[PosMayor]; Numeros[PosMayor] = aux; /* Llamado recursivo a funcion con el subvector de N-1 elementos */ OrdenarPorSeleccionRecursivo(Numeros, N - 1); * Funcion para leer un vector de numeros enteros desde un archivo. El * nombre del archivo se recibe como argumento, junto con el nombre del * vector donde se guardaran los valores. En el archivo de entrada el * primer valor indica el numero de elementos que vienen a continuacion. * La funcion retorna la cantidad de valores leidos y guardados. int LeerVector(char archivo[], int Numeros[]) { FILE *fh; int i, Cant; printf("leyendo datos de entrada\n"); /* Abrir el archivo pasado por la linea de comandos */ fh = fopen(archivo, "r"); if (fh == NULL) { printf("error abriendo el archivo: %s\n", archivo); /* Leer la cantidad de elementos del vector desde el archivo */ fscanf(fh, "%d", &Cant); /* Leer los numeros desde el archivo */ for (i = 0; i < Cant; i++) fscanf(fh, "%d", &Numeros[i]); /* fscanf requiere puntero: & */ /* Cerrar el archivo */ fclose(fh); return(cant);
* Funcion para imprimir por pantalla el contenido de un vector de enteros * de 'N' elementos. void MostrarVector(int Numeros[], int N) { int i; printf("el vector de %d enteros es:\n", N); for (i = 0; i < N; i++) printf("%4d", Numeros[i]); * Programa ejemplo para demostrar el ordenamiento por seleccion del mayor * en un vector de enteros de forma recursiva. * - Se lee un vector de numeros enteros desde un archivo. * - Se muestra el vector antes de ordenarlo. * - Se ordena el vector a traves de la funcion recursiva de * ordenamiento por seleccion. * - Se muestra el vector despues de ordenarlo. main(int argc, char *argv[]) { int Numeros[MAX_N]; int NumElementos; /* Verifica que el usuario haya escrito el nombre del archivo */ if (argc!= 2) { printf("uso: %s archivo\n", argv[0]); /* Leer un vector de enteros desde el archivo indicado*/ NumElementos = LeerVector(argv[1], Numeros); /* Mostrar el vector antes de ordenarlo */ printf("\nantes de Ordenar\n"); MostrarVector(Numeros, NumElementos); /* Ordenar el vector de numeros de forma recursiva */ OrdenarPorSeleccionRecursivo(Numeros, NumElementos); /* Mostrar el vector despues de ordenarlo */ printf("\n\ndespues de Ordenar\n"); MostrarVector(Numeros, NumElementos); Archivo de entrada 10 3-5 20 0 11 4 2 9-1 90 Ejemplo de ejecución C:\>ordsel entrada.txt Leyendo datos de entrada Antes de Ordenar El vector de 10 enteros es: 3-5 20 0 11 4 2 9-1 90 Despues de Ordenar El vector de 10 enteros es: -5-1 0 2 3 4 9 11 20 90
Ordenamiento por Selección (variante eligiendo el menor) Algoritmo recursivo escogiendo el menor: Si el vector tiene un único elemento no se hace nada. En caso contrario, se elige el menor de los elementos y se intercambia por el primero (posición de inicio). De esta forma, el primer elemento estará en su posición correcta. Luego se ordena el subvector que empieza en la siguiente posición. * Funcion recursiva que ordena un vector de enteros por seleccion. * Si el vector tiene un solo elemento no se hace nada. De lo contrario, * se elige el menor de los elementos y se intercambia por el primero del * vector (posicion Inicio). Luego se ordena el vector a partir de la * posicion Inicio + 1. void OrdenarPorSeleccionRecursivo(int Numeros[], int Inicio, int N) { int i, PosMenor, aux; /* Busca el menor elemento */ if (Inicio + 1 < N) { PosMenor = Inicio; /* Supone que el menor es el primero */ for (i = Inicio + 1; i < N; i++) if (Numeros[i] < Numeros[PosMenor]) PosMenor = i; /* Lleva a cabo el intercambio */ aux = Numeros[Inicio]; Numeros[Inicio] = Numeros[PosMenor]; Numeros[PosMenor] = aux; /* Llamado recursivo a la funcion con el subvector */ OrdenarPorSeleccionRecursivo(Numeros, Inicio + 1, N); * Ejemplo: Ordenamiento por seleccion de forma recursiva seleccionando el * menor elemento. #include <stdio.h> /* Para usar fscanf, FILE, fopen, fclose. */ #include <stdlib.h> #define MAX_N 50 /* Para la definicion del vector */ * Funcion recursiva que ordena un vector de enteros por seleccion. * Si el vector tiene un solo elemento no se hace nada. De lo contrario, * se elige el menor de los elementos y se intercambia por el primero del * vector (posicion Inicio). Luego se ordena el vector a partir de la * posicion Inicio + 1. void OrdenarPorSeleccionRecursivo(int Numeros[], int Inicio, int N) { int i, PosMenor, aux; if (Inicio + 1 < N) { /* Busca el menor elemento */ PosMenor = Inicio; /* Supone que el menor es el primero */ for (i = Inicio + 1; i < N; i++) if (Numeros[i] < Numeros[PosMenor]) PosMenor = i;
aux = Numeros[Inicio]; /* Lleva a cabo el intercambio */ Numeros[Inicio] = Numeros[PosMenor]; Numeros[PosMenor] = aux; /* Llamado recursivo a la funcion con el subvector */ OrdenarPorSeleccionRecursivo(Numeros, Inicio + 1, N); * Funcion para leer un vector de numeros enteros desde un archivo. El * nombre del archivo se recibe como argumento, junto con el nombre del * vector donde se guardaran los valores. En el archivo de entrada el * primer valor indica el numero de elementos que vienen a continuacion. * La funcion retorna la cantidad de valores leidos y guardados. int LeerVector(char archivo[], int Numeros[]) { FILE *fh; int i, Cant; printf("leyendo datos de entrada\n"); /* Abrir el archivo pasado por la linea de comandos */ fh = fopen(archivo, "r"); if (fh == NULL) { printf("error abriendo el archivo: %s\n", archivo); /* Leer la cantidad de elementos del vector desde el archivo */ fscanf(fh, "%d", &Cant); /* Leer los numeros desde el archivo */ for (i = 0; i < Cant; i++) fscanf(fh, "%d", &Numeros[i]); /* fscanf requiere puntero: & */ /* Cerrar el archivo */ fclose(fh); return(cant); * Funcion para imprimir por pantalla el contenido de un vector de enteros * de 'N' elementos. void MostrarVector(int Numeros[], int N) { int i; printf("el vector de %d enteros es:\n", N); for (i = 0; i < N; i++) printf("%4d", Numeros[i]); * Programa ejemplo para demostrar el ordenamiento por seleccion del menor * en un vector de enteros de forma recursiva. * - Se lee un vector de numeros enteros desde un archivo. * - Se muestra el vector antes de ordenarlo. * - Se ordena el vector a traves de la funcion recursiva de * de ordenamiento por seleccion. * - Se muestra el vector despues de ordenarlo. main(int argc, char *argv[]) { int Numeros[MAX_N]; int NumElementos; /* Verifica que el usuario haya escrito el nombre del archivo */ if (argc!= 2) { printf("uso: %s archivo\n", argv[0]); /* Leer un vector de enteros desde archivo */ NumElementos = LeerVector(argv[1], Numeros); /* Mostrar el vector antes de ordenarlo */
printf("\nantes de Ordenar\n"); MostrarVector(Numeros, NumElementos); /* Ordenar el vector de numeros de forma recursiva */ OrdenarPorSeleccionRecursivo(Numeros, 0, NumElementos); /* Mostrar el vector despues de ordenarlo */ printf("\n\ndespues de Ordenar\n"); MostrarVector(Numeros, NumElementos); Archivo de entrada 10 3-5 20 0 11 4 2 9-1 90 Ejemplo de ejecución C:\>ordsel entrada.txt Leyendo datos de entrada Antes de Ordenar El vector de 10 enteros es: 3-5 20 0 11 4 2 9-1 90 Despues de Ordenar El vector de 10 enteros es: -5-1 0 2 3 4 9 11 20 90 Ordenamiento por Selección (versión iterativa) Algoritmo iterativo escogiendo el mayor: Se itera tantas veces como elementos hay en el vector. En cada iteración se elige el mayor de los elementos y se intercambia por el último. Se decrementa N para que en la siguiente iteración se trate el siguiente. El orden en que se van ubicando los elementos es el mismo que en el caso recursivo.
* Funcion iterativa que ordena un vector de enteros por seleccion. * Si el vector tiene un solo elemento no se hace nada. De lo contrario, * se elige el mayor de los elementos y se intercambia por el ultimo del * vector (posicion Cant - 1). Luego se decrementa la cantidad de * elementos a ordenar y se vuelve a iterar. void OrdenarPorSeleccionIterativo(int Numeros[], int N) { int i, PosMayor, aux; /* Itera tantas veces como elementos hay en el vector. */ /* En cada iteracion ubica el elemento en la posicion N */ while (N > 1) { /* Busca el mayor */ PosMayor = 0; /* Supone que el mayor es el primero */ for (i = 1; i < N; i++) if (Numeros[i] > Numeros[PosMayor]) PosMayor = i; /* Lleva a cabo el intercambio */ aux = Numeros[N - 1]; Numeros[N - 1] = Numeros[PosMayor]; Numeros[PosMayor] = aux; N--; /* Decrementar la cantidad de elementos a ordenar */ * Ejemplo: Ordenamiento por seleccion de forma iterativa seleccionando el * mayor elemento. #include <stdio.h> /* Para usar fscanf, FILE, fopen, fclose. */ #include <stdlib.h> #define MAX_N 50 /* Para la definicion del vector */ * Funcion iterativa que ordena un vector de enteros por seleccion. * Si el vector tiene un solo elemento no se hace nada. De lo contrario, * se elige el mayor de los elementos y se intercambia por el ultimo del * vector (posicion Cant - 1). Luego se decrementa la cantidad de * elementos a ordenar y se vuelve a iterar. void OrdenarPorSeleccionIterativo(int Numeros[], int N) { int i, PosMayor, aux; /* Itera tantas veces como elementos hay en el vector. */ /* En cada iteracion ubica el elemento en la posicion N */ while (N > 1) { /* Busca el mayor */ PosMayor = 0; /* Supone que el mayor es el primero */ for (i = 1; i < N; i++) if (Numeros[i] > Numeros[PosMayor]) PosMayor = i; /* Lleva a cabo el intercambio */ aux = Numeros[N - 1]; Numeros[N - 1] = Numeros[PosMayor]; Numeros[PosMayor] = aux; N--; /* Decrementar la cantidad de elementos a ordenar */
* Funcion para leer un vector de numeros enteros desde un archivo. El * nombre del archivo se recibe como argumento, junto con el nombre del * vector donde se guardaran los valores. En el archivo de entrada el * primer valor indica el numero de elementos que vienen a continuacion. * La funcion retorna la cantidad de valores leidos y guardados. int LeerVector(char archivo[], int Numeros[]) { FILE *fh; int i, Cant; printf("leyendo datos de entrada\n"); /* Abrir el archivo pasado por la linea de comandos */ fh = fopen(archivo, "r"); if (fh == NULL) { printf("error abriendo el archivo: %s\n", archivo); /* Leer la cantidad de elementos del vector desde el archivo */ fscanf(fh, "%d", &Cant); /* Leer los numeros desde el archivo */ for (i = 0; i < Cant; i++) fscanf(fh, "%d", &Numeros[i]); /* fscanf requiere puntero: & */ /* Cerrar el archivo */ fclose(fh); return(cant); * Funcion para imprimir por pantalla el contenido de un vector de enteros * de 'N' elementos. void MostrarVector(int Numeros[], int N) { int i; printf("el vector de %d enteros es:\n", N); for (i = 0; i < N; i++) printf("%4d", Numeros[i]); * Programa ejemplo para demostrar el ordenamiento por seleccion del mayor * en un vector de enteros de forma iterativa. * - Se lee un vector de numeros enteros desde un archivo. * - Se muestra el vector antes de ordenarlo. * - Se ordena el vector a traves de la funcion iterativa de * ordenamiento por seleccion. * - Se muestra el vector despues de ordenarlo. main(int argc, char *argv[]) { int Numeros[MAX_N]; int NumElementos; /* Verifica que el usuario haya escrito el nombre del archivo */ if (argc!= 2) { printf("uso: %s archivo\n", argv[0]); /* Leer un vector de enteros desde archivo */ NumElementos = LeerVector(argv[1], Numeros); /* Mostrar el vector antes de ordenarlo */ printf("\nantes de Ordenar\n"); MostrarVector(Numeros, NumElementos); /* Ordenar el vector de numeros de forma iterativa */ OrdenarPorSeleccionIterativo(Numeros, NumElementos); /* Mostrar el vector despues de ordenarlo */ printf("\n\ndespues de Ordenar\n"); MostrarVector(Numeros, NumElementos);
Archivo de entrada 10 3-5 20 0 11 4 2 9-1 90 Ejemplo de ejecución C:\>ordsel entrada.txt Leyendo datos de entrada Antes de Ordenar El vector de 10 enteros es: 3-5 20 0 11 4 2 9-1 90 Despues de Ordenar El vector de 10 enteros es: -5-1 0 2 3 4 9 11 20 90
Complejidad de Algoritmos El estudio de la complejidad de los algoritmos intenta obtener medidas que indiquen cómo será el comportamiento de los algoritmos ante variaciones en las características de los datos de entrada (por ejemplo, la cantidad de datos). El orden de ejecución de un algoritmo, denotado por O(expresión) indica cómo será el comportamiento del tiempo de ejecución del algoritmo ante variaciones en los parámetros de la expresión. Por ejemplo, cuando se dice que un algoritmo tiene orden lineal respecto al número de elementos de entrada, n, y denotado por O(n), se quiere expresar que el tiempo de ejecución del algoritmo se incrementará linealmente conforme se incremente el número de elementos de entrada. Puede deducirse entonces que los algoritmos más deseables son aquellos que cuenten con órdenes de ejecución logarítmicos, y los menos deseables son aquellos con órdenes de ejecución exponenciales. Ordenamiento y Búsqueda Eficientes Cuando la cantidad de datos que se están manipulando es extremadamente grande, incluso un computador puede tener problemas para llevar a cabo búsquedas u ordenamientos en un tiempo razonable. El algoritmo de búsqueda lineal, como es de esperar, es de orden O(n), donde n es el número de elementos. El algoritmo de ordenamiento por selección es de orden O(n 2 ), donde n es el número de elementos. A continuación se estudiarán algoritmos que tienen complejidad O(log n). Búsqueda Binaria La búsqueda binaria puede aplicarse únicamente a un conjunto ordenado de datos. Por esto, supondremos que el vector que contiene los datos se encuentra ordenado ascendentemente (es decir, de menor a mayor). Algoritmo: Se analiza la posición del medio. Si ahí se encuentra el dato buscado, terminamos. Si el dato buscado es menor, se busca en el subvector menor, y si es mayor, se busca en el subvector mayor (aprovechando el hecho de que el vector está ordenado). Cada vez que se hace uno de estos análisis, se divide el vector en dos (de ahí su nombre, búsqueda binaria), y se descarta una de las mitades. Intuitivamente puede verse que la cantidad de trabajo necesaria para encontrar un elemento (o saber que no está), es mucho menor que para el caso de la búsqueda lineal.
* Funcion que realiza una busqueda binaria de un elemento en un vector * de enteros. La funcion recibe como parametros el vector, el indice de * inicio y de fin del vector, y el valor entero que se desea buscar. * Si el indice de inicio es mayor que el de fin se retorna que no se * encontro. En otro caso se divide el vector a la mitad, si el numero * buscado es menor que el que esta en la mitad se busca entonces en la * mitad inferior, si el numero buscado es mayor que el que esta en la * mitad se busca entonces en la mitad superior y en otro caso, el numero * en la mitad es el numero buscado. int BusquedaBinaria(int Numeros[], int Inicio, int Fin, int NumeroBuscado) { if (Inicio > Fin) return(no_encontrado); else { int pos = (Inicio + Fin) / 2; if (NumeroBuscado < Numeros[pos]) return(busquedabinaria(numeros, Inicio, pos - 1, NumeroBuscado)); else if (NumeroBuscado > Numeros[pos]) return(busquedabinaria(numeros, pos + 1, Fin, NumeroBuscado)); else return(pos); Ejemplo: Búsqueda Binaria * Ejemplo: Busqueda binaria de forma recursiva sobre un vector ordenado. #include <stdio.h> /* Para usar fscanf, FILE, fopen, fclose. */ #include <stdlib.h> #define MAX_N 50 /* Para la definicion del vector */ /* Valor a retornar cuando no se encuentra el elemento buscado */ #define NO_ENCONTRADO -1 * Funcion recursiva que ordena un vector de enteros por seleccion. * Si el vector tiene un solo elemento no se hace nada. De lo contrario, * se elige el mayor de los elementos y se intercambia por el ultimo del * vector (posicion N - 1). Luego se ordena el vector con N - 1 datos. void OrdenarPorSeleccionRecursivo(int Numeros[], int N) { int i, PosMayor, aux; if (N > 1) { /* Busca el mayor elemento */ PosMayor = 0; /* Supone que el mayor es el primero */ for (i=1; i<n; i++) if (Numeros[i] > Numeros[PosMayor]) PosMayor = i; /* Se lleva a cabo el intercambio */ aux = Numeros[N - 1]; Numeros[N - 1] = Numeros[PosMayor]; Numeros[PosMayor] = aux; /* Llamado recursivo a la funcion con el subvector de N-1 elementos */ OrdenarPorSeleccionRecursivo(Numeros, N - 1);
* Funcion para leer un vector de numeros enteros desde un archivo. int LeerVector(char archivo[], int Numeros[]) { FILE *fh; int i, Cant; printf("leyendo datos de entrada\n"); /* Abrir el archivo pasado por la linea de comandos */ fh = fopen(archivo, "r"); if (fh == NULL) { printf("error abriendo el archivo: %s\n", archivo); /* Leer la cantidad de elementos del vector desde el archivo */ fscanf(fh, "%d", &Cant); /* Leer los numeros desde el archivo */ for (i = 0; i < Cant; i++) fscanf(fh, "%d", &Numeros[i]); /* fscanf requiere puntero: & */ /* Cerrar el archivo */ fclose(fh); return(cant); * Funcion para imprimir por pantalla el contenido de un vector de enteros * de 'N' elementos. void MostrarVector(int Numeros[], int N) { int i; printf("el vector de %d enteros es:\n", N); for (i = 0; i < N; i++) printf("%4d", Numeros[i]); * Funcion que realiza una busqueda binaria de un elemento en un vector * de enteros. La funcion recibe como parametros el vector, el indice de * inicio y de fin del vector, y el valor entero que se desea buscar. * Si el indice de inicio es mayor que el de fin se retorna que no se * encontro. En otro caso se divide el vector a la mitad, si el numero * buscado es menor que el que esta en la mitad se busca entonces en la * mitad inferior, si el numero buscado es mayor que el que esta en la * mitad se busca entonces en la mitad superior y en otro caso, el numero * en la mitad es el numero buscado. int BusquedaBinaria(int Numeros[], int Inicio, int Fin, int NumeroBuscado) { if (Inicio > Fin) return(no_encontrado); else { int pos = (Inicio + Fin) / 2; if (NumeroBuscado < Numeros[pos]) return(busquedabinaria(numeros, Inicio, pos - 1, NumeroBuscado)); else if (NumeroBuscado > Numeros[pos]) return(busquedabinaria(numeros, pos + 1, Fin, NumeroBuscado)); else return(pos);
* Programa ejemplo para demostrar la busqueda binaria de forma recursiva * en un vector de enteros. Primero se lee un vector de numeros enteros * desde un archivo, se ordena y se le muestra al usuario. Luego se le * solicita a este que entre un numero y se busca en el vector a traves de * la busqueda binaria de forma recursiva. Si no se encuentra el numero se * le indica y si se encuentra se imprime la posicion que ocupa en vector. main(int argc, char *argv[]) { int Numeros[MAX_N]; int NumElementos, n, Posicion; /* Verifica que el usuario haya escrito el nombre del archivo */ if (argc!= 2) { printf("uso: %s archivo\n", argv[0]); /* Leer un vector de enteros desde archivo */ NumElementos = LeerVector(argv[1], Numeros); /* Ordenar el vector de numeros de forma recursiva */ OrdenarPorSeleccionRecursivo(Numeros, NumElementos); /* Mostrar el vector despues de ordenarlo */ MostrarVector(Numeros, NumElementos); /* Solicitar al usuario un numero a buscar */ printf("\ningrese un numero entero para buscarlo en el vector: "); scanf("%d", &n); /* scanf requiere puntero: & */ /* Buscar el numero en el vector */ Posicion = BusquedaBinaria(Numeros, 0, NumElementos - 1, n); if (Posicion == NO_ENCONTRADO) printf("\nel %d no esta en el vector.\n", n); else printf("\nel %d esta en la posicion %d.\n", n, Posicion); Versión Iterativa También es posible implementar el algoritmo de búsqueda binaria iterativamente, reemplazando la recursividad por un ciclo: /************************************************************************ * Funcion que realiza una busqueda binaria de un valor entero en vector * de enteros. La funcion recibe como parametros el vector, el indice de * inicio y de fin del vector, y el valor entero que se desea buscar. * Mientras el indice de inicio sea menor o igual que el de fin se divide * vector a la mitad, si el numero buscado es menor que el que esta en la * mitad se cambia el indice de fin para la posicion anterior a la mitad y * se vuelve a iterar, si el numero buscado es mayor que el que esta en la * mitad se cambia indice de inicio para la posicion posterior a la mitad * y se vuelve a iterar, y sino, el numero en la mitad es el buscado. * Si el indice de inicio se hace mayor que el de fin entonces se retorna * como No Encontrado. int BusquedaBinariaIterativa(int Numeros[], int Inicio, int Fin, int NumeroBuscado) { while (Inicio <= Fin) { int pos = (Inicio + Fin) / 2; if (NumeroBuscado < Numeros[pos]) Fin = pos - 1; else if (NumeroBuscado > Numeros[pos]) Inicio = pos + 1; else return pos; return NO_ENCONTRADO;
Quicksort El algoritmo Quicksort fue desarrollado en 1962 por C.A.R. Hoare, antes de que se implementaran los primeros lenguajes con capacidad para ejecutar funciones recursivas. El algoritmo, aplicado a un subvector vec[a... b] es: 1. Elegir un elemento x cualquiera del vector, entre a y b. El elemento x se llama pivote. Usualmente se elige el elemento que está en el medio. 2. Particionar el vector en dos subvectores: vec[a... p] y vec[p+1... b], intercambiando elementos de modo que todos los elementos que son menores que x estén a la izquierda y todos los mayores que x estén a la derecha. 3. Aplicar Quicksort al subvector vec[a... p] 4. Aplicar Quicksort al subvector vec[p+1... b] La función que implementa el algoritmo Quicksort podría implementarse de la siguiente manera: * Funcion recursiva que ordena un vector de enteros mediante Quicksort. * Si el vector no tiene mas de dos elementos no se hace nada. De lo * contrario, se particiona el vector y se aplica el metodo a los dos * subvectores que resultan de la particion. * Se reciben como parametros el vector y el indice inicial y final. void QuickSort(int Numeros[], int Inicio, int Fin) { int p; if (Inicio < Fin) { p = ParticionarVector(Numeros, Inicio, Fin); QuickSort(Numeros, Inicio, p); QuickSort(Numeros, p + 1, Fin); La función que lleva a cabo la selección del pivote y el particionamiento del vector sería: * Funcion para particionar un vector en dos subvectores, intercambiando * elementos de modo que todos los menores que el pivote esten a la * izquierda y los mayores a la derecha. * Se reciben como parametros el vector y el indice inicial y final. * Se retorna el indice para particionar el vector (posicion del pivote). int ParticionarVector(int Numeros[], int Inicio, int Fin) { int pivote = Numeros[(Inicio + Fin) / 2]; int izq = Inicio - 1; int der = Fin + 1; int aux; while (izq < der) { /* Busca el 1er. elemento de la derecha que haya que intercambiar */
do { izq++; while (Numeros[izq] < pivote); /* Busca el 1er. elemento de la izq. que haya que intercambiar */ do { der--; while (Numeros[der] > pivote); if (izq < der) { /* Lleva a cabo el intercambio */ aux = Numeros[izq]; Numeros[izq] = Numeros[der]; Numeros[der] = aux; return(der); Ejemplo: Ordenamiento con Quicksort de forma recursiva Ejemplo: Ordenamiento con quicksort de forma recursiva. #include <stdio.h> /* Para usar fscanf, FILE, fopen, fclose. */ #include <stdlib.h> #define MAX_N 50 /* Para la definicion del vector */ Funcion para particionar un vector en dos subvectores, intercambiando elementos de modo que todos los menores que el pivote esten a la izquierda y los mayores a la derecha. Se reciben como parametros el vector y el indice inicial y final. Se retorna el indice para particionar el vector (posicion del pivote). int ParticionarVector(int Numeros[], int Inicio, int Fin) { int pivote = Numeros[(Inicio + Fin) / 2]; int izq = Inicio - 1; int der = Fin + 1; int aux; while (izq < der) { /* Busca primer elemento de la derecha que haya que intercambiar */ do { izq++; while (Numeros[izq] < pivote); /* Busca primer elemento de la izquierda que haya que intercambiar */ do { der--; while (Numeros[der] > pivote); if (izq < der) { /* Lleva a cabo el intercambio */ aux = Numeros[izq]; Numeros[izq] = Numeros[der]; Numeros[der] = aux; return(der);
Funcion recursiva que ordena un vector de enteros mediante Quicksort. Si el vector no tiene mas de dos elementos no se hace nada. De lo contrario, se particiona el vector y se aplica el metodo a los dos subvectores que resultan de la particion. Se reciben como parametros el vector y el indice inicial y final. void QuickSort(int Numeros[], int Inicio, int Fin) { int p; if (Inicio < Fin) { p = ParticionarVector(Numeros, Inicio, Fin); QuickSort(Numeros, Inicio, p); QuickSort(Numeros, p + 1, Fin); * Funcion para leer un vector de numeros enteros desde un archivo. El * nombre del archivo se recibe como argumento, junto con el nombre del * vector donde se guardaran los valores. En el archivo de entrada el * primer valor indica el numero de elementos que vienen a continuacion. * La funcion retorna la cantidad de valores leidos y guardados. int LeerVector(char archivo[], int Numeros[]) { FILE *fh; int i, Cant; printf("leyendo datos de entrada\n"); /* Abrir el archivo pasado por la linea de comandos */ fh = fopen(archivo, "r"); if (fh == NULL) { printf("error abriendo el archivo: %s\n", archivo); /* Leer la cantidad de elementos del vector desde el archivo */ fscanf(fh, "%d", &Cant); /* Leer los numeros desde el archivo */ for (i = 0; i < Cant; i++) fscanf(fh, "%d", &Numeros[i]); /* fscanf requiere puntero: & */ /* Cerrar el archivo */ fclose(fh); return(cant); * Funcion para imprimir por pantalla el contenido de un vector de enteros * de 'N' elementos. void MostrarVector(int Numeros[], int N) { int i; printf("el vector de %d enteros es:\n", N); for (i = 0; i < N; i++) printf("%4d", Numeros[i]);
/************************************************************************ * Programa ejemplo para demostrar el ordenamiento con el algoritmo * Quicksort recursivo sobre un vector de enteros. * - Se lee un vector de numeros enteros desde un archivo. * - Se muestra el vector antes de ordenarlo. * - Se ordena el vector a traves de la funcion recursiva Quicksort. * - Se muestra el vector despues de ordenarlo. main(int argc, char *argv[]) { int Numeros[MAX_N]; int NumElementos; /* Verifica que el usuario haya escrito el nombre del archivo */ if (argc!= 2) { printf("uso: %s archivo\n", argv[0]); /* Leer un vector de enteros desde archivo */ NumElementos = LeerVector(argv[1], Numeros); /* Mostrar el vector antes de ordenarlo */ printf("\nantes de Ordenar\n"); MostrarVector(Numeros, NumElementos); /* Ordenar el vector de numeros de forma recursiva */ QuickSort(Numeros, 0, NumElementos-1); /* Mostrar el vector despues de ordenarlo */ printf("\n\ndespues de Ordenar\n"); MostrarVector(Numeros, NumElementos);
Comparación de algunas funciones de tiempo n log n n log n n2 n2 log n 1 0,00 0,0 1 0,0 2 0,69 1,4 4 2,8 5 1,61 8,0 25 40,2 10 2,30 23,0 100 230,3 20 3,00 59,9 400 1198,3 50 3,91 195,6 2500 9780,1 100 4,61 460,5 10000 46051,7 200 5,30 1059,7 40000 211932,7 500 6,21 3107,3 250000 1553652,0 1000 6,91 6907,8 1000000 6907755,3 2000 7,60 15201,8 4000000 30403609,8 5000 8,52 42586,0 25000000 212929829,8 10000 9,21 92103,4 100000000 921034037,2 20000 9,90 198069,8 400000000 3961395021,0 50000 10,82 540988,9 2500000000 27049445711,0 100000 11,51 1151292,5 10000000000 115129254649,7 200000 12,21 2441214,5 40000000000 488242905821,2 500000 13,12 6561181,7 250000000000 3280590844351,1 1000000 13,82 13815510,6 1000000000000 13815510557964,3 2000000 14,51 29017315,5 4000000000000 58034630954096,9 5000000 15,42 77124742,4 25000000000000 385623711759959,0 Ejemplo: Ordenando las líneas de un archivo Programa que ordena las líneas de un archivo y las guarda en otro. Ilustra el uso de operaciones sobre archivos, y aplica uno de los algoritmos de ordenamiento estudiados. Las líneas del archivo origen se leen una a una mediante fgets, y se almacenan en un vector de strings (o matriz de chars). Una vez ahí, se aplica un algoritmo de ordenamiento por selección y se procede a escribirlas al archivo de salida mediante fputs. Los nombres de los archivos, se pasan como argumentos a través de la línea de comandos. Modo de uso: filesort <archivo-origen> <archivo-destino>
* Ordena las lineas de un archivo y las guarda en otro: filesort * Ilustra el uso de operaciones sobre archivos. Las lineas del archivo * origen se leen una a una mediante fgets, y se almacenan en un vector * de strings (o matriz de chars). Una vez ahi, se aplica un algoritmo * de ordenamiento y se procede a escribirlas al archivo de salida * mediante fputs. Los nombres de los archivos, se pasan como argumentos * por la linea de comandos del programa. * Utilizar como: filesort <archivo-origen> <archivo-destino> #include <stdio.h> #include <stdlib.h> #include <string.h> /* Definicion de longitud maxima permitida para una linea del archivo */ #define MAX_LINEA 100 /* Definicion de la maxima cantidad de lineas permitidas en el archivo */ #define MAX_NUM_LINEAS 100 * Funcion recursiva que ordena un vector de N strings por seleccion. * Si el vector tiene un solo elemento no se hace nada. De lo contrario, * se elige el mayor de los elementos y se intercambia por el ultimo del * vector (posicion N - 1). Luego se ordena el vector con N - 1 datos. ************************************************************************/ void Ordenar(char VecStrings[MAX_NUM_LINEAS][MAX_LINEA], int N) { int i, PosMayor; char StrAux[MAX_LINEA]; if (N > 1) { /* Busca el mayor elemento */ PosMayor = 0; /* Supone que el mayor es el primero */ for (i=1; i<n; i++) if (strcmp(vecstrings[i], VecStrings[PosMayor])>0) PosMayor = i; /* Se lleva a cabo el intercambio */ strcpy(straux, VecStrings[N-1]); strcpy(vecstrings[n-1], VecStrings[PosMayor]); strcpy(vecstrings[posmayor], StrAux); /* Llamado recursivo a funcion con el subvector de N-1 elementos */ Ordenar(VecStrings, N - 1); main(int argc, char *argv[]) { FILE *origen, *destino; /* Descriptores para los archivos */ int NumLineas = 0; /* Numero de lineas leidas del archivo */ int i; /* Indice para el vector */ /* Vector donde se almacenara el archivo completo en memoria */ char vector[max_num_lineas][max_linea]; /* Verifica que se haya llamado correctamente el programa */ if (argc!= 3) { printf("uso correcto: sort <archivo-origen> <archivo-destino>\n"); /* Intenta abrir para lectura el archivo origen, tomando su nombre */ /* de la linea de comandos del programa. */ origen = fopen(argv[1], "r"); if (origen == NULL) { printf("no se pudo abrir archivo: %s\n", argv[2]);
/* Intenta abrir para escritura el archivo destino, tomando su */ /* nombre de la linea de comandos del programa. */ destino = fopen(argv[2], "w"); if (destino == NULL) { printf("no se pudo crear archivo: %s\n", argv[3]); fclose(origen); /* Ciclo para leer las lineas del archivo y guardarlas en el vector */ while (fgets(vector[numlineas], MAX_LINEA, origen)!= NULL) NumLineas++; /* Se ordena el vector */ Ordenar(vector, NumLineas); /* Ciclo para escribir en el archivo las lineas del vector */ for (i=0; i<numlineas; i++) fputs(vector[i], destino); /* Cierra los archivos */ fclose(origen); fclose(destino); Archivo de prueba original Volvo Renault Honda Daihatsu Chrysler Opel Alfa-Romeo Mitsubishi Suzuki Rover BMW Jaguar Ford Fiat Mercedes-Benz Volkswagen Dodge Nissan Chevrolet Kia Daewoo Toyota Audi Seat Subaru Citroen Porsche Peugeot Hyundai Mazda
Archivo de salida (resultado) Alfa-Romeo Audi BMW Chevrolet Chrysler Citroen Daewoo Daihatsu Dodge Fiat Ford Honda Hyundai Jaguar Kia Mazda Mercedes-Benz Mitsubishi Nissan Opel Peugeot Porsche Renault Rover Seat Subaru Suzuki Toyota Volkswagen Volvo