Recurrencia Programación II 3-4 de febrero de 2009

Ordenación rápida: Quick Sort Quick Sort divide el vector en dos partes que se ordenan recursivamente. Se puede resumir en tres pasos: 1. Escoger un Elemento de Pivote. 2. Particionar el vector en dos partes: una cuyos elementos son menores que el pivote, otra cuyos elementos son mayores. 3. Ordenar cada partición de manera recursiva con QuickSort.

Ordenación rápida: Quick Sort 1 accion QuickSort (V: vector de natural ; E,D: natural) 2variable medio, pivote, posicion_pivote : natural ; 3si (E >= D) entonces 4 // no hacer nada; intervalo ya ordenado 5sino 6 pivote := BuscarElementoPivote (V, E, D); 7 posicion_pivote := Particionar (V, E, D, pivote); 8 QuickSort ( V, E, posicion_pivote - 1); 9 QuickSort ( V, posicion_pivote, D); 10fsi 11 faccion

Ordenación rápida: Quick Sort 1 funcion BuscarElementoPivote (V: vector de natural ; i,j: natural) devuelve natural 2devolver V[j]; 3// hay diversas maneras de hacer esto.... // 4 ffuncion Existen varias maneras de obtener el elemento de pivote. En este caso se devuelve el último elemento. No hay ninguna manera que garantice mejores resultados.

1 funcion Particionar (V: vector de natural ; i,j,pivote: natural) devuelve natural 2variable E, D: natural ; 3E := i; 4D := j; 5mientras ( E < D ) hacer 6 mientras ( V[E] < pivote ) hacer // izquierda // 7 E := E + 1; 8 fmientras 9 mientras (V[D] >= pivote ) hacer // derecha // 10 D := D - 1; 11 fmientras 12 si (E < D ) entonces 13 Intercambiar ( V, E, D ); 14 fsi 15fmientras 16Intercambiar ( V, E, j ); 17devuelve E; 18 ffuncion Ordenación rápida: Quick Sort

¿Porqué inventar un algoritmo de ordenación más complejo?

Algoritmo QuickSort: Animación

Recorrido de grafos Muchos problemas se pueden representar por grafos Un grafo G=(V,E) consiste en un conjunto V de vértices y un conjunto E de aristas Hay varias razones para recorrer grafos: - visitar todos los vértices - buscar un(os) vértice(s) LM N OP G Q H J IK FED BC A

Búsqueda en profundidad (DFS; depth-first search) Recorre todos los vértices de una rama antes de seguir con la siguiente Visita a algunos vértices muy lejanos (profundos) del origen antes de otros cercanos La implementación más fácil es recursiva LM N OP G Q H J IK FED BC A

Búsqueda en profundidad (DFS) Para no visitar a un mismo vértice varias veces, hay que marcar los vértices ya visitados Sólo visitamos a un nodo si no ha sido marcado LM N OP G Q H J IK FED BC A

1 accion DFS(v: vertice) 2variable u: vertice; 3si (no marcado(v)) entonces 4marcado(v) := cierto; 5// procesamiento anterior de v 6para cada vecino u de v hacer 7 DFS(u); 8fpara 9// procesamiento posterior de v 10fsi 11 faccion Búsqueda en profundidad (DFS)

1 funcion DFS(v,w: vertice) devuelve booleano 2variable u: vertice; 3 b: booleano; 4si (marcado(v)) entonces 5devuelve falso; 6sino 7marcado(v) := cierto; 8si (v = w) entonces 9 devuelve cierto; 10fsi 11b := falso; 12para cada vecino u de v hacer 13 b := b o DFS(u, elem); 14fpara 15devuelve b; 16fsi 17 ffuncion Ejemplo: buscar un vértice w

Búsqueda en anchura (BFS; breadth-first search) Recorre los vértices en orden de su distancia desde el origen Visita a todos los vértices (el ancho) de un nivel antes de seguir con el siguiente Siempre encuentra la distancia mínima entre un vértice y el origen LM N OP G Q H J IK FED BC A

Búsqueda en anchura (BFS) Mantener una cola de vértices a procesar Cola: primer dato que entra, primero que sale (FIFO) Marcar vértices ya visitados (igual que para DFS) Agregar nuevos vértices a la cola Seguir hasta que la cola esté vacía

1 accion BFS(v: vertice) 2variable c: cola; 3 u,w: vertice; 4marcado(v) := cierto;// falso para otros vértices 5Inicializar(c); 6Agregar(c, v); 7mientras (no Vacia(c)) hacer 8u := Sacar(c); 9// procesamiento anterior de u 10para cada vecino w de u hacer 11 si (no marcado(w)) entonces 12 marcado(w) := cierto; 13 Agregar(c, w); 14 fsi 15fpara 16// procesamiento posterior de u 17fmientras 18 faccion Búsqueda en anchura (BFS)

1 tupla cola 2v: vector de vertice; i,d: natural; 3 ftupla Implementación de cola 1 accion Agregar(c: cola; v: vertice) 2c.v[c.d] := v; c.d := c.d + 1; 3 faccion 1 funcion Vacia(c: cola) devuelve booleano 2devuelve c.d > c.i; 3 ffuncion 1 funcion Sacar(c: cola) devuelve vertice 2c.i := c.i + 1; devuelve c.v[c.i – 1]; 3 faccion 1 accion Inicializar(c: cola) 2c.i := c.d := 1; 3 faccion

1 funcion BFS(v,x: vertice) devuelve natural 2variable c: cola; 3 u,w: vertice; 4marcado(v) := 0;// -1 para otros vértices 5Inicializar(c); 6Agregar(c, v); 7mientras (no Vacia(c)) hacer 8u := Sacar(c); 9para cada vecino w de u hacer 10 si (marcado(w) < 0) entonces 11 marcado(w) := marcado(u) + 1; 12 Agregar(c, w); 13 fsi 14fpara 15fmientras 16devuelve marcado(x); 19 ffuncion Ejemplo: devolver la distancia de v a un vértice x

Ordenación por intercalación: Merge Sort Merge Sort es un algoritmo recursivo para ordenar los elementos de un vector. Primero se divide el vector en dos partes iguales. Después se ordenan las dos partes recursivamente. Finalmente se combinan las dos partes ordenadas para obtener el resultado.

Ordenación por intercalación: Merge Sort 1 funcion MergeSort (V: vector de natural ; E,D: natural) devuelve vector de natural 2variable medio : natural ; 3 V e, V d : vector de natural ; 4si (E >= D) entonces 5 devuelve [ V[E] ]; 6sino 7 medio := ( E + D ) / 2; 8 V e := MergeSort ( V, E, medio ); 9 V d := MergeSort ( V, D, medio+1 ); 10 devuelve Combina (V e, V d, medio – E + 1, D – medio ); 11fsi 12 ffuncion

1 funcion Combina (V 1,V 2 : vector de natural ; m,n: natural) devuelve vector de natural 2variable resultado : vector de natural ; 3 r, i, j : natural; 4r := 1; i := 1; j := 1 5mientras (( i <= m) y ( j <= n)) hacer 6 si (V 1 [i] <= V 2 [j] ) entonces 7 resultado[r] := V 1 [i]; 8 i := i + 1; r := r + 1; 9 sino 10 resultado[r] := V 2 [j]; 11 j := j + 1; r := r + 1; 12 fsi 13fmientras 14mientras ( i <= m ) hacer 15 resultado[r] := V 1 [i]; 16 i := i + 1; r := r + 1; 17fmientras 18mientras ( j <= n) hacer 19 resultado[r] := V 2 [j]; 20 j := j + 1; r := r + 1; 21fmientras 22devuelve resultado; 23 ffuncion

Dividir en el centro Intercalar las Soluciones Ordenar recursivament e Ordenación por intercalación: Merge Sort

Llamada recursiva 1 ( MergeSort ) Llamada recursiva 2 ( MergeSort ) Llamada recursiva 3 ( MergeSort ) Volver 3 a 2 ( Combina ) Volver 2 a 1 ( Combina ) Combina

Algoritmo MergeSort: Animación toronto.edu/%7Eneto/teaching/238/16/merg esort.html