1 / 23

Recurrencia

Programación II 3-4 de febrero de 2009. Recurrencia. 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 .

stuart
Download Presentation

Recurrencia

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  2. Ordenación rápida: Quick Sort • Quick Sortdivide el vector en dos partes que se ordenan recursivamente. Se puede resumir en tres pasos: • 1. Escogerun 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.

  3. Ordenación rápida: Quick Sort • 1 accionQuickSort(V: vectorde natural; E,D: natural) • variablemedio, pivote, posicion_pivote : natural; • si (E >= D) entonces • // no hacer nada; intervalo ya ordenado • sino • pivote := BuscarElementoPivote(V, E, D); • posicion_pivote := Particionar(V, E, D, pivote); • QuickSort ( V, E, posicion_pivote - 1); • QuickSort ( V, posicion_pivote , D); • fsi • 11 faccion

  4. Ordenación rápida: Quick Sort • 1 funcionBuscarElementoPivote(V: vectorde natural; i,j: natural) devuelvenatural • devolver V[j]; • // 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.

  5. Ordenación rápida: Quick Sort • 1 funcionParticionar (V: vectorde natural; i,j,pivote: natural) devuelvenatural • variable E, D: natural; • E := i; • D := j; • mientras ( E < D ) hacer • mientras ( V[E] < pivote)hacer// izquierda // • E := E + 1; • fmientras • mientras (V[D] >= pivote)hacer// derecha // • D := D - 1; • fmientras • si (E < D ) entonces • Intercambiar ( V, E, D ); • fsi • fmientras • Intercambiar ( V, E, j ); • devuelve E; • 18 ffuncion

  6. Ordenación rápida: Quick Sort ¿Porqué inventar un algoritmo de ordenación más complejo?

  7. Algoritmo QuickSort: Animación http://www.cs.mu.oz.au/aia/QuickSort.html http://www.cs.ubc.ca/spider/harrison/Java/ http://en.wikipedia.org/wiki/Quicksort

  8. A B C D E F G H I J K L M N O P Q 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)

  9. A B C D E F G H I J K L M N O P Q 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

  10. 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 A B C D E F G H I J K L M N O P Q

  11. Búsqueda en profundidad (DFS) • 1 accionDFS(v: vertice) • variableu: vertice; • si (no marcado(v)) entonces • marcado(v) := cierto; • // procesamiento anterior de v • para cada vecino u de v hacer • DFS(u); • fpara • // procesamiento posterior de v • fsi • 11 faccion

  12. Ejemplo: buscar un vértice w • 1 funcionDFS(v,w: vertice) devuelvebooleano • variableu: vertice; • b: booleano; • si (marcado(v)) entonces • devuelvefalso; • sino • marcado(v) := cierto; • si (v = w) entonces • devuelvecierto; • fsi • b := falso; • para cada vecino u de v hacer • b := b o DFS(u, elem); • fpara • devuelve b; • fsi • 17 ffuncion

  13. A B C D E F G H I J K L M N O P Q 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

  14. 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

  15. Búsqueda en anchura (BFS) • 1 accionBFS(v: vertice) • variable c: cola; • u,w: vertice; • marcado(v) := cierto; // falso para otros vértices • Inicializar(c); • Agregar(c, v); • mientras (noVacia(c)) hacer • u := Sacar(c); • // procesamiento anterior de u • para cada vecino w de u hacer • si (no marcado(w)) entonces • marcado(w) := cierto; • Agregar(c, w); • fsi • fpara • // procesamiento posterior de u • fmientras • 18 faccion

  16. Implementación de cola • 1 tupla cola • v: vector de vertice; i,d: natural; • 3 ftupla • 1 accionInicializar(c: cola) • c.i := c.d := 1; • 3 faccion • 1 accionAgregar(c: cola; v: vertice) • c.v[c.d] := v; c.d := c.d + 1; • 3 faccion • 1 funcionVacia(c: cola) devuelvebooleano • devuelve c.d > c.i; • 3 ffuncion • 1 funcionSacar(c: cola) devuelvevertice • c.i := c.i + 1; devuelve c.v[c.i – 1]; • 3 faccion

  17. Ejemplo: devolver la distancia de v a un vértice x • 1 funcionBFS(v,x: vertice) devuelvenatural • variable c: cola; • u,w: vertice; • marcado(v) := 0; // -1 para otros vértices • Inicializar(c); • Agregar(c, v); • mientras (noVacia(c)) hacer • u := Sacar(c); • para cada vecino w de u hacer • si (marcado(w) < 0) entonces • marcado(w) := marcado(u) + 1; • Agregar(c, w); • fsi • fpara • fmientras • devuelve marcado(x); • 19 ffuncion

  18. 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.

  19. Ordenación por intercalación: Merge Sort • 1 funcionMergeSort(V: vectorde natural; E,D: natural) devuelvevector de natural • variablemedio : natural; • Ve , Vd : vector de natural ; • si (E >= D) entonces • devuelve [ V[E] ]; • sino • medio := ( E + D ) / 2; • Ve := MergeSort ( V, E, medio ); • Vd := MergeSort ( V, D, medio+1 ); • devuelveCombina (Ve , Vd , medio – E + 1, D – medio ); • fsi • 12 ffuncion

  20. 1 funcionCombina (V1,V2 : vector de natural ; m,n: natural) devuelvevector de natural • variableresultado : vector de natural; • r, i, j : natural; • r := 1; i := 1; j := 1 • mientras (( i <= m) y ( j <= n)) hacer • si (V1 [i] <= V2 [j] ) entonces • resultado[r] := V1[i]; • i := i + 1; r := r + 1; • sino • resultado[r] := V2[j]; • j := j + 1; r := r + 1; • fsi • fmientras • mientras ( i <= m)hacer • resultado[r] := V1[i]; • i := i + 1; r := r + 1; • fmientras • mientras ( j <= n)hacer • resultado[r] := V2[j]; • j := j + 1; r := r + 1; • fmientras • devuelve resultado; • 23 ffuncion

  21. Dividir en el centro Ordenar recursivamente Intercalar las Soluciones Ordenación por intercalación: Merge Sort

  22. Ordenación por intercalación: Merge Sort Llamada recursiva 1 ( MergeSort ) Llamada recursiva 2 ( MergeSort ) Llamada recursiva 3 ( MergeSort ) 6 12 4 9 8 13 5 Volver 3 a 2 ( Combina ) 4 6 9 12 5 8 13 Volver 2 a 1 ( Combina ) 4 5 6 8 9 12 13 Combina

  23. Algoritmo MergeSort: Animación http://www.cs.toronto.edu/%7Eneto/teaching/238/16/mergesort.html http://www.cs.ubc.ca/spider/harrison/Java/ http://www.sorting-algorithms.com/merge-sort

More Related