Informe Investigacin Algoritmos: Ordenamiento Quicksort y Bsqueda Binaria

Sede: ejercito 171 , Santiago Integrantes: Alfredo Fernndez, Pablo Zenteno, Vctor Astorga Asignatura: Programacin y Estructura de datos Curso Carrera : T29200A : Tcnico en computacin e informtica

Profesor : Carol Otarola Fecha entrega: 06/12/2012

ndice

Portada......1 ndice.....2 Introduccin..3 Mtodo Quicksort4 Algoritmo mtodo Quicksort..6 Bsqueda Binaria....7 Algoritmo bsqueda binaria .....8

Implementacin de cdigo Quicksort y bsqueda binaria.9 Recorrido ordenamiento quicksort ..13 Recorrido bsqueda binaria..14
Conclusin.15 Bibliografa 16

Introduccin
Ordenar significa reagrupar o reorganizar un conjunto de datos u objetos en una secuencia especifica. Los procesos de ordenacin y bsqueda son frecuentes en nuestra vida diaria. Vivimos en un mundo desarrollado en donde cada vez se hace ms indispensable de contar con informacin actualizada y oportuna para realizar ciertas tareas o bien tomar decisiones, es por ello que el ordenamiento de datos es indispensable para lograr una bsqueda ms eficiente y que la informacin est lista en el momento que se precise utilizar, es por esta razn que en el presente trabajo se dar a conocer el ordenamiento Quicksort y bsqueda binaria, se explicara su funcionamiento sencillo y fcil de aplicar en un cdigo realizado y pensado en el ordenamiento en base a Quicksort y bsqueda binaria la cual es muy rpida y eficiente cabe mencionar que el mtodo Quicksort es uno de los mas eficientes cdigos de ordenamiento en comparacin a otros mtodos de ordenamiento.

Mtodo Quicksort
El ordenamiento rpido (quicksort en ingls) es un algoritmo creado por el cientfico britnico en computacin Charles Antony Richard Hoare en 1960, basado en la tcnica de divide y vencers, que permite, en promedio, ordenar n elementos en un tiempo proporcional. Se considera el algoritmo ms rpido y actualmente se usa en infinidades de programas, y aplicaciones del mundo moderno. Ya que la mayor parte del tiempo los computadores lo ocupan ordenando cosas un algoritmo de ordenacin como este es un regalo de dios para los programadores.

El algoritmo fundamental es el siguiente: Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote. Resituar los dems elementos de la lista a cada lado del pivote, de manera que a un lado queden todos los menores que l, y al otro los mayores. Los elementos iguales al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la implementacin deseada. En este momento, el pivote ocupa exactamente el lugar que le corresponder en la lista ordenada. La lista queda separada en dos sub listas, una formada por los elementos a la primero del pivote, y otra por los elementos a su ltimo. Repetir este proceso de forma recursiva para cada sub lista mientras stas contengan ms de un elemento. Una vez terminado este proceso todos los elementos estarn ordenados. Como se puede suponer, la eficiencia del algoritmo depende de la posicin en la que termine el pivote elegido. En el mejor caso, el pivote termina en el centro de la lista, dividindola en dos sub listas de igual tamao. En este caso, el orden de complejidad del algoritmo es O(nlogn). En el peor caso, el pivote termina en un extremo de la lista. El orden de complejidad del algoritmo es entonces de O (n). El peor caso depender de la implementacin del algoritmo, aunque habitualmente ocurre en listas que se encuentran ordenadas, o casi ordenadas. Pero principalmente depende del pivote, si por ejemplo el algoritmo implementado toma como pivote siempre el primer elemento del array, y el array que le pasamos est ordenado, siempre va a generar a su izquierda un array vaco, lo que es ineficiente. En el caso promedio, el orden es O(nlog n). No es extrao, pues, que la mayora de optimizaciones que se aplican al algoritmo se centren en la eleccin del pivote.

Tcnicas de eleccin del pivote Tomar un elemento cualquiera como pivote tiene la ventaja de no requerir ningn clculo adicional, lo cual lo hace bastante rpido. Sin embargo, esta eleccin a ciegas siempre provoca que el algoritmo tenga un orden de O(n) para ciertas permutaciones de los elementos en la lista. Otra opcin puede ser recorrer la lista para saber de antemano qu elemento ocupar la posicin central de la lista, para elegirlo como pivote. Esto puede hacerse en O(n) y asegura que hasta en el caso peor el algoritmo sea O(nlog n). No obstante, el clculo adicional rebaja bastante la eficiencia del algoritmo en el caso promedio. La opcin a medio camino es tomar tres elementos de la lista - por ejemplo, el primero, el segundo, y el ltimo - y compararlos, eligiendo el valor del medio como pivote. Tcnicas de reposicionamiento Una idea preliminar para ubicar el pivote en su posicin final sera contar la cantidad de elementos menores que l, y colocarlo un lugar ms arriba, moviendo luego todos esos elementos menores que l a su izquierda, para que pueda aplicarse la recursividad. Existe, no obstante, un procedimiento mucho ms efectivo. Se utilizan dos ndices: i, al que llamaremos ndice izquierdo, y j, al que llamaremos ndice derecho. El algoritmo es el siguiente: Recorrer la lista simultneamente con i y j: por la izquierda con i (desde el primer elemento), y por la derecha con j (desde el ltimo elemento). Cuando lista[i] sea mayor que el pivote y lista[j] sea menor, se intercambian los elementos en esas posiciones. Repetir esto hasta que se crucen los ndices. El punto en que se cruzan los ndices es la posicin adecuada para colocar el pivote, porque sabemos que a un lado los elementos son todos menores y al otro son todos mayores. El algoritmo es el siguiente:

void quicksort(int *vector[],int primero , int ultimo){ int i,j , central; int 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 tmp; tmp = vector[i]; vector[i] = vector[j]; vector[j] = tmp; i++; j--; } }while(i<=j); if (primero<j) quicksort(vector, primero,j); if(i<ultimo) quicksort(vector, i,ultimo); }

Bsqueda binaria
Este algoritmo permite buscar de una manera ms eficiente un dato dentro de un arreglo, para hacer esto se determina el elemento central del arreglo y se compara con el valor que se esta buscando, si coincide termina la bsqueda y en caso de no ser as se determina si el dato es mayor o menor que el elemento central, de esta forma se elimina una mitad del arreglo junto con el elemento central para repetir el proceso hasta encontrarlo o tener solo un elemento en el arreglo. Para poder aplicar este algoritmo se requiere que el arreglo este ordenado. Su implementacin es la siguiente:

La bsqueda binaria slo se puede implementar si el arreglo est ordenado. La idea consiste en ir dividiendo el arreglo en mitades. Por ejemplo supongamos que tenemos este vector: int vector[10] = {2,4,6,8,10,12,14,16,18,20};

La clave que queremos buscar es 6. El algoritmo funciona de la siguiente manera

1. Se determinan un ndice arriba y un ndice abajo, Iarriba=0 e Iabajo=9 respectivamente.

2. Se determina un ndice central, Icentro = (Iarriba + Iabajo)/2, en este caso quedara Icentro = 4.

3. Evaluamos si vector[Icentro] es igual a la clave de bsqueda, si es igual ya encontramos la clave y devolvemos Icentro.

4. Si son distintos, evaluamos si vector[Icentro] es mayor o menor que la clave, como el arreglo est ordenado al hacer esto ya podemos descartar una mitad del arreglo asegurndonos que en esa mitad no est la clave que buscamos. En nuestro caso vector[Icentro] = 4 < 6, entonces la parte del arreglo vector[0...4] ya puede descartarse.

5. Reasignamos Iarriba o Iabajo para obtener la nueva parte del arreglo en donde queremos buscar. Iarriba, queda igual ya que sigue siendo el tope. Iabajo lo tenemos subir hasta 5, entonces quedara Iarriba = 9, Iabajo = 5. Y volvemos al paso 2. Si la clave no fuese encontrada en algn momento Iabajo > Iarriba, con un while vamos a controlar esta condicin para salir del ciclo en tal caso y devolver -1 (clave no encontrada). Algoritmo int busquedabin(int *vector[],int n,int clave){ int central, bajo, alto;

int valorcentral; bajo=0; alto = n-1; while(bajo<=alto){ central=(bajo+alto)/2; valorcentral=vector[central]; if(clave==valorcentral) return central; else if(clave<valorcentral) alto =central-1; else bajo =central+1; } return -1; }

Implementacin de cdigo Quicksort y bsqueda binaria

En esta parte se mostrara un cdigo implementando el ordenamiento Quicksort y la Bsqueda binaria en un solo programa demostrando como se complementan ambas funciones el la cual se comentara las situaciones mas importantes del cdigo para que sea entendible y quede demostrado la fcil implementacin de este mismo adems de su recorrido suponiendo los siguientes valores ingresados al vector: 10, 5, 8, 3, 6.

#include <stdio.h> #include <conio.h> #include <stdlib.h>

//librerias

void llenar(int *vector[], int tam) // se recibe vector y int en tam { int i; printf("Ingresar 5 valores\n"); for(i=0;i<tam;i++) // se recorre vector para llenado { printf("Ingresar valor: "); scanf("%d",&vector[i]); // se ingresa numero en cada posicin de vector } } void quicksort(int *vector[],int primero , int ultimo){ // se recibe vector y dos enteros inicial y final de vector int i,j , central; int pivote; central=(primero+ultimo)/2; //para saber cul es el centro se toma el vector inicial y posicin final dividido 2 pivote= vector[central]; //nuestro pivote es igual a posicin de vector en central i= primero; //i es igual a primero que seria j= ultimo; //j es igual a lo que contiene ultimo do{ //se realiza aunque sea una vez cumpliendo la condicin siguiente

while(vector[i]<pivote)i++; //si vector en i es menor que pivote entra en el ciclo y i aumenta while(vector[j]>pivote)j--; //si vector en j es mayor que pivote entra en el ciclo y j disminuye if(i<=j){ int tmp; tmp = vector[i]; vector[i] = vector[j]; vector[j] = tmp; i++; j--; } }while(i<=j); if (primero<j) //i es menor o igual a j si es verdadero entones entra al ciclo //si primero es menor a j entra y se llama recursivamente a funcin con // vector, primero y j dejando pendiente el resto del cdigo //cuando ya all terminado con el anterior vuelve con este cdigo //llamndose recursivamente enviando vector, i y ultimo //tmp guarda lo que contenga vector en i //vector en i guarda lo que contenga vector en j //vector en j es igual a tmp //i aumenta // j disminuye //si i es menor o igual a j ejecuta acciones

quicksort(vector, primero,j); if(i<ultimo) quicksort(vector, i,ultimo); }

int busquedabin(int *vector[],int n,int clave){

//se recibe vector un entero que seria //final de vector y el nmero a buscar

int central, bajo, alto; int valorcentral; bajo=0; alto = n-1; while(bajo<=alto){ //se inicializa en cero //se inicializa en n-1 //si bajo es menor o igual alto ingresa

central=(bajo+alto)/2; //central es la suma de bajo y alto dividido en 2 valorcentral=vector[central]; if(clave==valorcentral) return central; else if(clave<valorcentral) //valor central es igual a lo que contiene vector en central //si numero a buscar es igual a lo que contiene valorcentral //retorna posicin donde esta ubicado el numero buscado // si clave es igual a valor central entra

10

alto =central-1; else bajo =central+1; } return -1; }

//y alto es igual a central -1

//sino bajo es igual a central mas 1

//si no se cumple condicin retorna -1 para salir del programa

void imprimir(int **vector, int lalong) { int cont; for (cont=0;cont<lalong;cont++) {

//se recibe a vector y largo de vector

//se crea un ciclo para recorrer el vector y mostrarlo en pantalla

printf("En casilla %dnmero es %d\n", cont,vector[cont]); // se muestra posicin de vector y lo que contiene vector } } int main(){ int pos, num, h, vector[4]; //se inicializan variables y vector int opc; while(h>0){ //se crea un ciclo para el men

printf("***********************************\n"); printf("1 llenar el vector\n"); printf("2 ordenacin quicksort\n"); printf("3 imprimir\n"); printf("4 busqueda binaria\n"); printf("5 salir\n"); printf("***********************************\n"); printf("ingrese opc a realizar\n"); scanf("%d",&opc); switch (opc){ case 1: llenar(&vector,5);break; // se llama a funcin llenar enviando direccin de vector y 5 // se ingresa opcin deseada // se ingresa segn opcin ingresada

11

case 2: quicksort(vector,0,5-1);break; //se llama a funcin quicksort enviando a vector, posicin // Inicial 0 y posicin final que seria 5-1 case 3: imprimir(&vector,5);break; case 4: printf("Ingresa el elemento a buscar: "); scanf("%d",&num); //se ingresa numero a buscar binaria a //se llama a funcin enviando vector y largo de vector

pos=busquedabin(&vector,5,num); // se guarda en pos lo que reciba de la funcin bsqueda vector,5 y numero a buscar

printf("El elemento %d se encuentra en la posicin %d \n",num,pos);break; //se imprime en pantalla resultado de la bsqueda case 5: printf("adios "); h=-1 ;break; } } system("PAUSE"); return 0; } //se sale de programa

12

Recorrido del programa

Estos son los elementos en nuestro vector y recorremos con Quicksort para ordenar veamos que sucede:
vector[0] vector[1] vector[2] vector[3] vector[4] 10 5 8 3 6
Primer recorrido
i o 1 j 4 3 central (0+4)/2=2 pivote 8 vector[0] vector[1] vector[2] vector[3] vector[4] 10 5 8 3 6 6 10 tmp 10 primero 0 ultimo 4

Al visualizar la tabla i queda en 1, j queda en 3, central queda en 2, nuestro pivote es 8, tmp queda en 10, primero queda 0, ultimo queda 4, vector en posicin 0 que contena 10 ahora guarda 6 y vector en posicin 4 que contena 6 ahora guarda 10 es decir se intercambiaron, estos son los primeros cambios en nuestro vector el resto del vector queda igual asta el momento y seguimos. Segundo recorrido
i o 1 j 3 2 central (0+3)/2=1 pivote 5 vector[0] vector[1] vector[2] vector[3] vector[4] 6 5 8 3 10 3 6 tmp 6 primero 0 ultimo 3

Al visualizar la tabla en su segundo recorrido i queda en 1, j queda en 2, central queda en 1, nuestro pivote es 5, tmp queda en 6, primero queda 0, ultimo queda 3, vector en posicin 0 que contenia 6 ahora guarda 3 y vector en posicin 3 que contena 3 ahora guarda 6 se intercambiaron una vez mas ya tenemos nuestro segundo cambio en nuestro vector el resto del vector queda igual asta el momento y seguimos. Tercer recorrido
i o 1 2 j 2 1 0 central (0+2)/2=1 pivote 5 vector[0] vector[1] vector[2] vector[3] vector[4] 3 5 8 6 10 8 5 tmp 5 primero 0 ultimo 2

Al visualizar la tabla en su tercer recorrido i queda en 2, j queda en 0, central queda en 1, nuestro pivote es 5, tmp queda en 5, primero queda 0, ultimo queda 2, vector en posicin 1 que contena 5 guarda 8 y vector en posicin 2 que contena 8 ahora guarda 5 ya tenemos nuestro tercer cambio en nuestro vector el resto del vector queda igual asta el momento y pasamos a nuestro segundo ciclo recursivo y seguimos. Cuarto recorrido
i 1 2 j 4 3 2 central (0+4)/2=2 pivote 5 vector[0] vector[1] vector[2] vector[3] vector[4] 3 8 5 6 10 6 8 tmp 8 primero 1 ultimo 4

13

Al visualizar la tabla en su cuarto recorrido tomamos los valores que quedaron antes de pasar a la primera recursividad es decir lo que esta en la tabla 1, entonces quedara asi i queda en 2, j queda en 2, central queda en 2, nuestro pivote es 5, tmp queda en 8, primero queda 1, ultimo queda 4, vector en posicin 1 que contena 8 ahora guarda 6 y vector en posicin 3 que contena 6 ahora guarda 8 ya tenemos nuestro cuarto cambio en nuestro vector el resto del vector queda igual asta el momento y seguimos recursivamente. Quinto recorrido
i 1 2 j 2 1 central (1+2)/2=1 pivote 6 vector[0] vector[1] vector[2] vector[3] vector[4] 3 6 5 8 10 5 6 tmp 6 primero 1 ultimo 2

Al visualizar la tabla en su quinto recorrido i queda en 2, j queda en 1, central queda en 1, nuestro pivote es 6, tmp queda en 6, primero queda 1, ultimo queda 2, vector en posicin 1 que contenia 6 ahora guarda 5 y vector en posicin 2 que contenia 5 ahora guarda 6 ya tenemos nuestro quinto y ultimo cambio en nuestro vector ya que esta ordenado sale y nuestro vector queda de la siguiente manera.

vector[0] vector[1] vector[2] vector[3] vector[4] 3 5 6 8 10

Bsqueda binaria
Aqu realizamos el recorrido de nuestra bsqueda binaria simularemos que nuestra bsqueda es el nmero 8 veamos que sucede:
vector[0] vector[1] vector[2] vector[3] vector[4] 3 5 6 8 10 n 5 clave 8 central 2 3 bajo 0 (2+1)=3 alto 4 valorcentral 6 8

Aqu recibimos nuestro vector con su datos ya ordenado adems recibimos tamao de vector que seria n que es 5 y numero a buscar clave que sera 8 inicializamos variables a trabajar y decimos que bajo es igual a 0 y alto es igual a n-1 igual a 5 decimos que si bajo es menor o igual a alto ingresamos al ciclo central queda en 2 y valorcentral es igual a lo que contiene vector en posicin central es decir 6. Si clave es igual igual a valorcentral retorna central la posicin donde se encuentra nuestro numero a buscar pero como no se cumple condicin seguimos si clave es menor a valorcentral entonces alto es igual a central-1 es decir 3 pero no se cumple la condicin, seguimos bajo es igual a central+1 es decir bajo ahora es igual a 3 y continuamos con el ciclo while y central ahora es 3, valorcentral es igual a lo que contiene vector en posicin central es decir 8. Si clave es igual igual a valorcentral retorna central la posicin donde se encuentra nuestro numero a buscar que es 8 que esta vez si se cumple y se sale de la bsqueda as de fcil y rpido.

14

Conclusin
Los algoritmos que explicamos en el informe son los ms utilizados hasta hoy en da, lo cual se basan en una simple resea que es divide y vencers por el hecho del quicksort es el que divide el vector en 2 sealando un pivote en el centro y empieza a comparar en el sentido si es mayor que el pivote o es menor y los intercambia hasta dejarlo de menor a mayor utilizando recursividad asta lograr ordenar nuestro vector en cambio la bsqueda binaria tiene que tener un vector previamente ordenado lo cual ya realizo nuestro algoritmo de Quicksort y lo que hace es dividir el vector igual en dos y compara si es menor ,mayor o igual en primera instancia y si es menor se dirige a la izquierda y si es mayor a la derecha o igual devuelve la posicin que se encuentra utilizando un ciclo while para recorrer todo el vector, esta se realiza hasta encontrar el numero buscado, si no lo encuentra devuelve NULL o no encontrado. Habiendo realizado nuestro programa utilizando estos dos algoritmos nos quedo la impresin que es muy fcil de aplicar y entender y que es muy eficaz tal cual indicaban en muchos libros y fuentes de informacin sobre el algoritmo como se logro ver en este informe que lo explicamos de varias formas tanto la forma tradicional, comentando el cdigo y realizando su recorrido para el fcil entendimiento de quien pueda ver nuestro informe.

15

Bibliografa

16