cap1.2 tutor recursividad vectores

Programación II

Recursión con Vectores

Ing. Mary López

Universidad Autónoma Gabriel Rene MorenoFICCT

Semestre II/2015

Ejercicio 1Búsqueda Binaria

bool BusBin(int *vec,int inicio,int final,int clave) { bool flag,res; if(inicio > final) flag=false; else {

int m = (inicio + final)/2;int x=vec[m];if(clave < x) flag = BusBin(vec, inicio, m-1, clave);else if(clave > x) flag = BusBin(vec, m+1, final, clave); else flag = true;

} return flag;

}

AlgoritmosDe

Ordenación

Algoritmos de Ordenación

La ordenación de elementos según un orden ascendente o descendente influye en la velocidad y simplicidad de los algoritmos que los manipulan.

En general, un conjunto de elementos se almacenan en forma ordenada con el fin de simplificar la recuperación de información manualmente, o facilitar el acceso mecanizado a los datos de una manera más eficiente.

Cada algoritmo ordenación estará compuesto de las siguientes operaciones básicas: COMPARACIONES que prueban si A i< A j ó A i < B

(donde B es una variable auxiliar) INTERCAMBIOS: permutar los contenidos de A i y A j

ASIGNACIONES de la forma B = Ai Ai = Aj Aj= B

Ejercicio 2: MergeSort (Ver 2)

Prerrequisito : Comprender la Recursión

El MERGESORT consiste en : Dividir los elementos en dos grupos de la misma

longitud aproximadamente. Ordenar de forma independiente cada sub-grupo. Mezclar los dos subgrupos ordenados para producir

la secuencia final ordenada.

Algoritmo de fácil división y difícil unión

Ejercicio 2: MergeSort

Una ejecución de merge-sort esta representado por un árbol binario :

La raíz es la primera llamada Cada nodo representa una llamada recursiva de merge-sort

• La secuencia esta sin ordenar antes de la ejecución y después de su partición

• La Secuencia se ordenada al final de la ejecución. Cada hoja es llamada hasta obtener secuencia de longitud

cero o un solo elemento.

6 2 9 4 3 8 6 1

Particion del conjunto en 2 partes

7 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

7 2 2 7 9 4 4 9 3 8 3 8 6 1 1 6

7 7 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9


Llamada recursiva partición

6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

7 2 2 7 9 4 4 9 3 8 3 8 6 1 1 6

7 7 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 7 9 4 4 9 3 8 3 8 6 1 1 6

7 7 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Llamada recursiva Particion

mergeSort


6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 7 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Llamada recursiva Caso Base

mergeSort


6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

Mezcla Merge

merge


6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 6 9 4 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9


mergeSort


6 2 9 4 2 4 7 9 3 8 6 1 1 3 8 6

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

9 9 4 4

Mezcla Merge

merge


Mezcla Merge

6 2 9 4 2 4 6 9

6 2 2 6 9 4 4 9 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

merge



6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort



6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort



6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


Mezcla Merge

6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

merge



6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort



6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort



6 2 9 4 2 4 6 9 3 8 6 1

6 2 2 6 9 4 4 9 3 8 3 8 6 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

mergeSort


Mezcla Merge

6 2 9 4 2 4 6 9 3 8 6 1 |

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

merge


Mezcla Merge

6 2 9 4 2 4 6 9 3 8 6 1 1 3 6 8

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 7 8 9

merge


6 2 9 4 2 4 6 9 3 8 6 1 1 3 6 8

6 2 2 6 9 4 4 9 3 8 3 8 6 1 1 6

6 6 2 2 9 9 4 4 3 3 8 8 6 6 1 1

6 2 9 4 3 8 6 1 1 2 3 4 6 6 8 9

Mezcla Merge

merge



void mergeSort (int *A, unsigned int bajo, unsigned int alto, unsigned int n) {

if (bajo < alto) { //Si hay más de un elemento

int medio = (alto + bajo)/2;

mergeSort (A, bajo, medio,n);

mergeSort (A, medio+1, alto,n); //Proceso que mezcla el resultado de las dos llamadas anteriores

merge (A, bajo, medio+1, alto,n);

}

}


void merge (int *A, unsigned int bajo, unsigned int medio, unsigned int alto,unsigned int n){unsigned int ini_1 = bajo; //Variable de primer elemento de la primera subsecunsigned int fin_1 = medio -1; //Variable del último elemento de la primera subsecunsigned int ini_2 = medio; //Variable del primer elemento de la segunda subsecunsigned int i = bajo; //Variable para controlar posiciones del vector resultanteint *Temp=new int[n];/* Temp es un array ya definido*/while (( ini_1 <= fin_1) && (ini_2<= alto)) { if (A[ini_1] <= A[ini_2]) Temp[i++] = A[ini_1++]; else Temp[i++] = A[ini_2++]; }


while (ini_1 <= fin_1) //Si se agotaron los elementos de la segunda subsecuencia Temp[i++] = A[ini_1++];while (ini_2 <= alto) //Si se agotaron los de la primera subsecuencia Temp[i++] = A[ini_2++];//Paso todos los elementos del Temporal al arrayfor (i = bajo; i <= alto; i++) A[i] = Temp[i];}

Ejercicio 3QuickSort

En la ordenación rápida, la secuencia inicial de elementos se divide en dos sub-secuencias de diferente tamaño.

La obtención de las dos sub-secuenciases el proceso que acarrea más tiempo mientras que la combinación de las sub-secuencias ordenadas para obtener la secuencia final consume muy poco tiempo.

Para dividir en dos la secuencia de elementos, se selecciona un elemento sobre el cual efectuar la división, el PIVOTE.

Se dividen los elementos en dos grupos, los elementos menores que el pivote y aquellos mayores o igual al pivote.

Algoritmo de difícil división y fácil unión,


La elección del elemento Pivote se puede seleccionar de diferentes formas: El mayor de los dos primeros elementos distintos encontrados. Otros criterios (1ro, Ultimo, el del centro, etc).

Para ordenar los elementos comprendidos entre Ai y Aj

1. Si desde Ai hasta Aj hay al menos dos elementos distintos

entonces comenzar la aplicación del algoritmo.2. Seleccionar el PIVOTE como el elemento mayor de los dos

primeros elementos distintos encontrados.3. Insertar PIVOTE en la última posición.


4. Permutar los elementos desde Ai hasta Aj de modo que, para algún i <= k <= j :

Ai, ..., Ak-1< PIVOTE

Ak, ..., Aj>= PIVOTE

Es decir, en las (k-1) primeras posiciones queden los elementos menores que pivote, mientras que en la posición k hacia delante queden los elementos mayores o iguales que el pivote.

5. Invocar a:

QUICKSORT desde i hasta (k –1)QUICKSORT desde k hasta j


35

1) Elegir Pivote: Tomar un elemento

2) Dividir: Reordenar los elementos tal que x va a su posición final E

3) Recursión y Vencer: Ordenar recursivamente

Ejercicio 3 - QuickSortInicia

Ejercicio 3 - QuickSortÍndicePivotei ini Fin

0 1 2 3 4 5 6 77 6 2 10 4 5 9 8 Pivote

Como 10 es mayor que 8 este no esta en una posición correcta. Luego debemos continuar avanzando con i hasta encontrar uno menor que el pivote 8.

ÍndicePivoteini i Fin

0 1 2 3 4 5 6 77 6 2 10 4 5 9 8 Pivote



0 1 2 3 4 5 6 77 6 2 10 4 5 9 8 Pivote

Encontramos el 4. Luego este lo intercambiamos por el 10

Partir (1)

Ejercicio 3 - QuickSort


0 1 2 3 4 5 6 77 6 2 4 10 5 9 8 Pivote



0 1 2 3 4 5 6 77 6 2 4 10 5 9 8 Pivote



0 1 2 3 4 5 6 77 6 2 4 5 10 9 8 Pivote




0 1 2 3 4 5 6 77 6 2 4 5 10 9 8 Pivote


El apuntador i llego a su posición máxima. Finalmente hay que mover el pivote 8 a la posición donde quedo el apuntador indicepivote ya que este es mayor y debe ir a la derecha.

ÍndicePivoteini Fin

0 1 2 3 4 5 6 77 6 2 4 5 10 9 8 Pivote

ÍndicePivoteini Fin

0 1 2 3 4 5 6 77 6 2 4 5 8 9 10

PivoteEl algoritmo termina poniendo el Pivote en su posición de ordenación correcta y al mismo tiempo divide al conjunto en 2 para continuar ordenando


partición


quickSort (I)


0 1 2 3 47 6 2 4 5 ip piv ini fin i

0 5 0 4 01 1

0 1 2 3 4 2 22 6 7 4 5 3

4

0 1 2 3 42 4 7 6 5

0 1 2 3 42 4 5 6 7

Partir (2)

partición


0 12 4 ip piv ini fin i

0 4 0 1 01 1

0 12 4

0 12 4

Partir (3)


quickSort (I)


partición


quickSort (D)


partición


quickSort (D)


partición


Ejercicio 3: QuickSort

void quickSort( int *A, int ini, int fin ){

if (ini < fin){

int indicepivote = particion(A,ini, fin); //El pivote ya esta en su posición correcta //Por eso no se lo toma encuenta en la union

quickSort(A, ini, indicepivote – 1 );quickSort(A, indicepivote+1, fin);

}

}


int particion(int *A,int ini, int fin){int pivote = A[fin];int indicepivote = ini;for ( int i=indicepivote; i< fin ; i++) { if (A[i] < pivote) { //Intercambiar solo si i es distinto de indicepivote

intercambiar(A, i ,indicepivote); indicepivote=indicepivote+1; } } intercambiar(A, indicepivote,fin); return indicepivote;}


void intercambiar( int *A, int ptr1, int ptr2 ){ int temp; temp = A[ptr1]; A[ptr1] = A[ptr2]; A[ptr2] = temp;}

cap1.2 tutor recursividad vectores

Education