tema 5 derivacion algoritmos
DESCRIPTION
algoritmosTRANSCRIPT
![Page 1: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/1.jpg)
d l í d l óMetodología de la Programación
Tema V. Diseño de algoritmos iterativosTema V. Diseño de algoritmos iterativos
Diseño de algoritmos iterativos correctosDiseño de algoritmos iterativos correctos
1MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos
![Page 2: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/2.jpg)
1 Derivación de algoritmos1. Derivación de algoritmos
2. Diseño de algoritmos correctos con bucles
3. Diseño de bucles mediante debilitamiento de su postcondiciónde su postcondición
4. Diseño de algoritmos iterativos más complejos
5. Aplicación al diseño de algoritmos iterativos5. Aplicación al diseño de algoritmos iterativos de búsqueda en una tabla
6 li ió l di ñ d l i d6. Aplicación al diseño de algoritmos de ordenación interna de una tabla
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 2
![Page 3: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/3.jpg)
1 Derivación de algoritmos1. Derivación de algoritmos
Diseñar el siguiente algoritmoDiseñar el siguiente algoritmo
{ x=A ∧ y=B }??????{ x=B ∧ y=A }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 3
![Page 4: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/4.jpg)
Hagamos un intento de diseño Para empezar vamos aHagamos un intento de diseño. Para empezar vamos amodificar el valor de una de las variable. Por ejemplode la variable <x>:de la variable <x>:
{ x=A ∧ y=B }x := x + y;{ x=A+B ∧ y=B }???{ x=B ∧ y=A }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 4
![Page 5: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/5.jpg)
Hagamos que el valor de la variable <y> sea el queHagamos que el valor de la variable <y> sea el que debe finalmente tener finalmente, es decir, <A>:
{ x=A ∧ y=B }x := x + y;{ x=A+B ∧ y=B }{ x=A+B ∧ y=B }y := x – y;{ x=A+B ∧ y=A }???{ x=B ∧ y=A }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 5
![Page 6: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/6.jpg)
Sólo falta modificar el valor de la variable <x> para queSólo falta modificar el valor de la variable <x> para que valga <B>, sin alterar el valor de <y>:
{ x=A ∧ y=B }x := x + y;{ x=A+B ∧ y=B }{ x=A+B ∧ y=B }y := x – y;{ x=A+B ∧ y=A }x := x – y;{ x=B ∧ y=A }???{ x=B ∧ y=A }
¿ Es correcto el diseño realizado ?
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 6
![Page 7: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/7.jpg)
¡ El diseño está concluido y es correcto (regla del¡ El diseño está concluido y es correcto (regla del debilitamiento de la postcondición) !
{ x=A ∧ y=B }x := x + y;{ x=A+B ∧ y=B }y := x – y;{ x=A+B ∧ y=A }{ y }x := x – y;{ x=B ∧ y=A }⇒⇒{ x=B ∧ y=A }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 7
![Page 8: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/8.jpg)
He aquí el algoritmo deducido por derivación delHe aquí el algoritmo deducido por derivación del código a partir de su especificación:
{ x=A ∧ y=B }x := x + y;y := x – y;y := x – y;x := x – y;{ x=B ∧ y=A }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 8
![Page 9: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/9.jpg)
Hagamos un segundo diseño modificando en primerHagamos un segundo diseño, modificando en primer lugar el valor de la variable <y>:
{ x=A ∧ y=B }y := x – y;y : x y;{ x=A ∧ y=A‐B }???{ }{ x=B ∧ y=A }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 9
![Page 10: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/10.jpg)
Hagamos que el valor de la variable <x> sea igual aHagamos que el valor de la variable <x> sea igual a <B>, sin modificar el valor de la variable <y>:
{ x=A ∧ y=B }y := x – y;y : x y;{ x=A ∧ y=A‐B }x := x – y;{ }{ x=B ∧ y=A‐B }???{ x=B ∧ y=A }{ y }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 10
![Page 11: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/11.jpg)
Sólo falta modificar el valor de la variable <y> para queSólo falta modificar el valor de la variable <y> para que valga <A>, sin alterar el valor de <x>:
{ x=A ∧ y=B }y := x – y;y : x y;{ x=A ∧ y=A‐B }x := x – y;{ }{ x=B ∧ y=A‐B }y := x + y;{ x=B ∧ y=A }{ y }
¡Hemos sabido derivar un segundo diseño del¡Hemos sabido derivar un segundo diseño del algoritmo!
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 11
![Page 12: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/12.jpg)
2 Diseño de algoritmos correctos con bucles2. Diseño de algoritmos correctos con bucles
Diseñar el siguiente algoritmo con un bucle:Diseñar el siguiente algoritmo con un bucle:
{ P }??????{ Q }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 12
![Page 13: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/13.jpg)
Escribimos el bucle y ponemos interrogantes dondeEscribimos el bucle y ponemos interrogantes dondehaya que incluir código para completar el diseño:
{ P }???mientrasQue ??? hacermientrasQue ??? hacer
???finMQ???{ Q }
Lo primero que debemos hacer es dar con un métodoiterativo que resuelva el problema y resumirlo en unpredicado invariante. Otra alternativa es escribirprimero el invariante y deducir de él un métodoiterativo.
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 13
![Page 14: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/14.jpg)
Anotamos en el bucle el predicado invariante <I>:Anotamos en el bucle el predicado invariante <I>:
{ P }???mientrasQue ??? hacer { I } (1)
???finMQ???{ Q }{ Q }
Paso 1 El predicado invariante <I> puede deducirse enPaso 1. El predicado invariante <I> puede deducirse enmuchos casos aplicando técnicas de debilitamiento dela postcondición <Q>la postcondición <Q>.
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 14
![Page 15: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/15.jpg)
Paso 2 Diseñamos el código previo al bucle:Paso 2. Diseñamos el código previo al bucle:
{ P }( )Acción_previa diseñar este código (2)
{ I }mientrasQue ??? hacer { I } (1)Q { } ( )
???finMQ??????{ Q }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 15
![Page 16: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/16.jpg)
Pasos 3 y 4 Deducimos la condición <C> del bucle y elPasos 3 y 4. Deducimos la condición <C> del bucle y elcódigo posterior al bucle:
{ P }Acción_previa (2){ I }{ I }mientrasQue C hacer { I } (1),(3)
???finMQ{ ¬C ∧ I }Acción posterior diseñar este código (4)_p g ( ){ Q }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 16
![Page 17: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/17.jpg)
Pasos 5 y 6 Diseñamos el código interior del buclePasos 5 y 6. Diseñamos el código interior del bucle,garantizando su terminación mediante una función decota:cota:
{ P }( )Acción_previa (2)
{ I }mientrasQue C hacer { I } { f_cota } (1),(3),(6)Q { } { _ } ( ),( ),( )
{ I ∧ C }Acción_a_iterar diseñar este código (5){ I }{ I }
finMQ{ I ∧ ¬C }Acción_posterior (4){ Q }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 17
![Page 18: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/18.jpg)
3 Diseño de bucles mediante debilitamiento3. Diseño de bucles mediante debilitamiento de su postcondición
Derivar un diseño iterativo del siguiente algoritmo:
{ cierto }??????{ sumar(T) = (Σα∈[1,N].T[α]) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 18
![Page 19: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/19.jpg)
El esquema algorítmico iterativo a diseñar es elEl esquema algorítmico iterativo a diseñar es elsiguiente:
{ cierto }??????mientrasQue ??? hacer { ¿I? }
???finMQ???{ sumar(T) = (Σα∈[1,N].T[α]) }{ ( ) ( α [ , ] [α]) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 19
![Page 20: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/20.jpg)
Paso 1 Debilitamos la postcondición sustituyendo la constantePaso 1. Debilitamos la postcondición sustituyendo la constante<N> por una variable, por ejemplo, <hasta>, y el resultado de lafunción <sumar(T)> por una variable, por ejemplo <suma>:( )
{ cierto }{ }???mientrasQue ??? hacer { I: suma = (Σα∈[1,hasta].T[α]) }
??????finMQ???{ sumar(T) = (Σα∈[1,N].T[α]) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 20
![Page 21: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/21.jpg)
Paso 2 Procedemos a diseñar las acciones previas al bucle:Paso 2. Procedemos a diseñar las acciones previas al bucle:
{ cierto }{ cierto }hasta := 1; suma := T[1];{ suma = (Σα∈[1,hasta].T[α]) }mientrasQue ??? hacer { I: suma = (Σα∈[1,hasta].T[α]) }
???finMQfinMQ???{ sumar(T) = (Σα∈[1,N].T[α]) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 21
![Page 22: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/22.jpg)
Pasos 3 y 4 Deducimos ahora la condición del bucle y el códigoPasos 3 y 4. Deducimos ahora la condición del bucle y el códigoposterior al bucle:
{ cierto }hasta := 1; suma := T[1];hasta := 1; suma := T[1];{ suma = (Σα∈[1,hasta].T[α]) }mientrasQue not (hasta=N) hacer
{ I: suma = (Σα∈[1,hasta].T[α]) }???
finMQQ{ suma = (Σα∈[1,hasta].T[α]) ∧ hasta=N }devuelve suma; { (T) (Σ [1 N] T[ ]) }{ sumar(T) = (Σα∈[1,N].T[α]) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 22
![Page 23: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/23.jpg)
Pasos 5 y 6 Deducimos el código interior al bucle e identificamosPasos 5 y 6. Deducimos el código interior al bucle e identificamosuna función de cota que asegure su terminación:
{ cierto }hasta := 1; suma := T[1];hasta := 1; suma := T[1];{ suma = (Σα∈[1,hasta].T[α]) }mientrasQue not (hasta=N) hacer { f_cota = N – hasta }
{ suma = (Σα∈[1,hasta].T[α]) ∧ hasta≠N }hasta := hasta + 1; suma := suma + T[hasta];{ suma = (Σα∈[1,hasta].T[α]) }{ ( [ , ] [ ]) }
finMQ{ suma = (Σα∈[1,hasta].T[α]) ∧ hasta=N }de el e devuelve suma; { sumar(T) = (Σα∈[1,N].T[α]) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 23
![Page 24: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/24.jpg)
El algoritmo iterativo diseñado es el siguiente:El algoritmo iterativo diseñado es el siguiente:
{ cierto }hasta := 1; suma := T[1];mientrasQue not (hasta=N) hacer
{ suma = (Σα∈[1,hasta].T[α]) }{ suma (Σα∈[1,hasta].T[α]) }hasta := hasta + 1; suma := suma + T[hasta];
finMQd ldevuelve suma; { sumar(T) = (Σα∈[1,N].T[α]) }
Conviene anotar los bucles con el predicado invariante que nosh b l d dha abierto las puertas de su diseño ya que constituye unexcelente elemento de documentación del código.
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 24
![Page 25: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/25.jpg)
Nuevo problema de diseño iterativo Derivar un diseñoNuevo problema de diseño iterativo. Derivar un diseñoiterativo del siguiente algoritmo que trabaja con unfichero <f> de datos numéricos:fichero <f> de datos numéricos:
{ cierto }???{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }{ ( [ , ( )] ( , )) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 25
![Page 26: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/26.jpg)
El esquema algorítmico a diseñar es el siguiente:El esquema algorítmico a diseñar es el siguiente:
{ cierto }???mientrasQue ??? hacer { ¿I? }Q { ¿ }
???finMQ??? ??? { suma = (Σα∈[1,numDatos(f)].dato(f,α)) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 26
![Page 27: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/27.jpg)
Paso 1 Debilitamos la postcondición sustituyendo el valorPaso 1. Debilitamos la postcondición sustituyendo el valorconstante <numDatos(f)> por el valor variable<numLeídos(f)>:( )
{ cierto }{ }???mientrasQue ??? hacer
{ I: modo(f) Lec{ I: modo(f) = Lec∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }
???finMQ??? { suma = (Σα∈[1 numDatos(f)] dato(f α)) }{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 27
![Page 28: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/28.jpg)
Paso 2 Procedemos a diseñar las acciones previas al bucle:Paso 2. Procedemos a diseñar las acciones previas al bucle:
{ cierto }{ cierto }iniciarLectura(f); suma := 0.0;{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }mientrasQue ??? hacer
{ I: modo(f) = Lec∧ suma = (Σα∈[1 numLeídos(f)] dato(f α)) }∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }
???finMQ??? { suma = (Σα∈[1,numDatos(f)].dato(f,α)) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 28
![Page 29: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/29.jpg)
Pasos 3 y 4 Deducimos ahora la condición del bucle y el códigoPasos 3 y 4. Deducimos ahora la condición del bucle y el códigoposterior al bucle:
{ cierto }iniciarLectura(f); suma := 0.0;{ suma = (Σα∈[1 numLeídos(f)] dato(f α)) }{ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }mientrasQue not finFichero(f) hacer
{ I: modo(f) = Lec∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }
???finMQQ{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) ∧ finFichero(f) ∧ finFichero(f)=(numLeídos(f)=numDatos(f)) }∧ finFichero(f)=(numLeídos(f)=numDatos(f)) }
nula; { vamos a eliminarla por ser innecesaria }{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 29
![Page 30: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/30.jpg)
Pasos 5 y 6 Deducimos el código interior al bucle e identificamosPasos 5 y 6. Deducimos el código interior al bucle e identificamosuna función de cota que asegure su terminación:
{ cierto }iniciarLectura(f); suma := 0 0;iniciarLectura(f); suma := 0.0;{ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }mientrasQue not finFichero(f) hacer
{ f_cota = numDatos(f) ‐ numLeídos(f) }{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) ∧ ¬finFichero(f) ( )∧ finFichero(f)=(numLeídos(f)≠numDatos(f)) }
leer(f, nuevo); suma := suma + nuevo;{ modo(f) = Lec ∧ suma = (Σα∈[1 numLeídos(f)] dato(f α)) }{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }
finMQ{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 30
![Page 31: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/31.jpg)
El algoritmo iterativo diseñado es el siguiente:El algoritmo iterativo diseñado es el siguiente:
{ cierto }iniciarLectura(f); suma := 0.0;mientrasQue not finFichero(f) hacer
{ modo(f) = Lec ∧ suma = (Σα∈[1,numLeídos(f)].dato(f,α)) }{ modo(f) Lec ∧ suma (Σα∈[1,numLeídos(f)].dato(f,α)) }leer(f, nuevo); suma := suma + nuevo;
finMQ{ (Σ [ t (f)] d t (f )) }{ suma = (Σα∈[1,numDatos(f)].dato(f,α)) }
Recordamos que conviene anotar los bucles con el predicadoinvariante que nos ha abierto las puertas de su diseño ya queconstituye un excelente elemento de documentación del código.
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 31
![Page 32: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/32.jpg)
4 Diseño de algoritmos iterativos más4. Diseño de algoritmos iterativos más complejos
Diseñar el siguiente algoritmo sin utilizar la operación de potenciaciónde potenciación.
{ n≥0 }???{ elevar(x,n) = xn }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 32
![Page 33: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/33.jpg)
Aplicaremos un método cálculo basado en las siguienteAplicaremos un método cálculo basado en las siguiente propiedades.
Método de cálculo de xn de coste logarítmico en <n>:
• n 0 → xn 1 0• n=0 → xn = 1.0• n>0 ∧ n mod 2 = 0 → xn = [xn/2]2
• n>0 n mod 2 ≠ 0 → xn x [xn/2]2• n>0 ∧ n mod 2 ≠ 0 → xn = x.[xn/2]2
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 33
![Page 34: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/34.jpg)
El esquema algorítmico a diseñar es el siguiente:El esquema algorítmico a diseñar es el siguiente:
{ n≥0 }???mientrasQue ??? hacer { ¿I? }Q { ¿ }
???finMQ??? ??? { elevar(x,n) = xn }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 34
![Page 35: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/35.jpg)
Un invariante del bucle que permita resolver el problema no es inmediato.Un invariante del bucle que permita resolver el problema no es inmediato.Para construirlo introducimos las variables nVar (valor variable delexponente), resultado (almacena el resultado parcial y final), e (exponentepotencia de 2) y potencias (potencias de 2) :potencia de 2) y potencias (potencias de 2) :
{ Invariante: xn = resultado.[xnVar]e ∧ potencias=xe }
x nVar resultado invariante potencias e
2 0 27 0 [ 27]1 1x 27 1.0 x27 = 1.0 [x27]1 x1 1
x 13 x x27 = x [x13]2 x2 2
x 6 x3 x27 x3 [x6]4 x4 4x 6 x3 x27 = x3 [x6]4 x4 4
x 3 x3 x27 = x3 [x3]8 x8 8
x 1 x11 x27 = x11 [x1]16 x16 16
27 1 2 8 16
x 1 x x x [x ] x 16
x 0 x27 x27 = x27 [x0]32 x32 32
Cálculos realizados: x27 = 1.x1.x2.x8.x16
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 35
![Page 36: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/36.jpg)
Paso 1 Esquema iterativo del algoritmo a derivar ElPaso 1. Esquema iterativo del algoritmo a derivar. Elinvariante del bucle se deduce a partir del método decálculo a aplicar:cálculo a aplicar:
{ n≥0 }???mientrasQue ??? hacerQ
{ Inv: xn = resultado.[xnVar]e ∧ potencias = xe }???
finMQfinMQ??? { elevar(x,n) = xn }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 36
![Page 37: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/37.jpg)
Paso 2 Diseñamos el código previo al bucle:Paso 2. Diseñamos el código previo al bucle:
{ n≥0 }nVar := n; resultado := 1.0; e := 1; potencias := x;{ xn = resultado.[xnVar]e ∧ potencias = xe }{ [ ] p }mientrasQue ??? hacer
{ Inv: xn = resultado.[xnVar]e ∧ potencias = xe }??????
finMQ??? { elevar(x,n) = xn }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 37
![Page 38: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/38.jpg)
Pasos 3 y 4 Deducimos la condición del bucle y elPasos 3 y 4. Deducimos la condición del bucle y elcódigo posterior a él:
{ n≥0 }nVar := n; resultado := 1.0; e := 1; potencias := x;p{ xn = resultado.[xnVar]e ∧ potencias = xe }mientrasQue not (nVar=0) hacer
{ Inv: xn = resultado [xnVar]e ∧ potencias = xe }{ Inv: xn = resultado.[xnVar]e ∧ potencias = xe }???
finMQ{ xn = resultado.[xnVar]e ∧ potencias = xe ∧ nVar=0 }devuelve resultado; { elevar(x,n) = xn }{ elevar(x,n) x }
nVar=0 → xn = resultado.[xnVar]e = resultado.[x0]e
lt d [ ] lt d= resultado.[1]e = resultado
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 38
![Page 39: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/39.jpg)
Pasos 5 y 6 Diseñamos el código interior del bucle yPasos 5 y 6. Diseñamos el código interior del bucle yproponemos una función de cota que permite probar suterminación:
{ n≥0 }nVar : n; resultado : 1 0; e : 1; potencias : x;nVar := n; resultado := 1.0; e := 1; potencias := x;mientrasQue not (nVar=0) hacer { f_cota : nVar }
{ xn = resultado.[xnVar]e ∧ potencias= xe ∧ nVar≠0 }si not (nVar mod 2 = 0) entonces
resultado := potencias*resultado;finSifinSinVar := nVar/2; e:= 2*e; potencias:= potencias*potencias;{ xn = resultado.[xnVar]e ∧ potencias= xe }
fifinMQdevuelve resultado; { elevar(x,n) = xn }
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 39
![Page 40: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/40.jpg)
El resultado del diseño iterativo es el siguiente:El resultado del diseño iterativo es el siguiente:
{ n≥0 }nVar := n; resultado := 1.0; e := 1; potencias := x;mientrasQue not (nVar=0) hacer
{ xn = resultado.[xnVar]e ∧ potencias= xe }{ x resultado.[x ] ∧ potencias x }si not (nVar mod 2 = 0) entonces
resultado := potencias*resultado;fi SifinSinVar := nVar/2; e:= 2*e; potencias:= potencias* potencias;
finMQdevuelve resultado; { elevar(x,n) = xn }
Se ha anotado el bucle con el predicado invariante que resume el método de cálculo aplicadométodo de cálculo aplicado.
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 40
![Page 41: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/41.jpg)
5 Aplicación al diseño de algoritmos iterativos5. Aplicación al diseño de algoritmos iterativos de búsqueda en una tabla
Elementos definidos en un programa escrito en Ada.
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Definición del tipo tpTabla que almacena <N> datos de‐‐ tipo tpD‐‐ tipo tpD‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐N : constant integer := ... ; ‐‐ Núm. datos de las tablassubtype tpIndice is integer range 1..N;type tpTabla is array (tpIndice) of tpD;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 41
![Page 42: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/42.jpg)
Problema 5 1 Derivar un diseño iterativo para elProblema 5.1. Derivar un diseño iterativo para elsiguiente algoritmo Ada.
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD) function buscar (T : in tpTabla; dato : in tpD)
return tpIndice is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
( [ ] ( ) )‐‐ Pre: (∃α∈[1,N].T(α)=dato)‐‐ Post: T(buscar(T,dato))=dato‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 42
![Page 43: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/43.jpg)
Esquema del algoritmo iterativo a diseñarEsquema del algoritmo iterativo a diseñar.
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐f ti b (T i t T bl d t t t D) function buscar (T : in tpTabla; dato : out tpD)
return tpIndice is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: (∃α∈[1,N].T(α)=dato)‐‐ Post: T(buscar(T,dato))=dato‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
???while ??? loop ‐‐ Invariante
???end loop;p;???
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 43
![Page 44: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/44.jpg)
Paso 1 Proponemos un predicado invariante para el buclePaso 1. Proponemos un predicado invariante para el bucle
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
‐‐ (∃α∈[1,N].T(α)=dato)???hil ??? l (∀ [ h t ] ( ) d t )while ??? loop ‐‐ Inv: (∀α∈[1,hasta‐1].T(α)≠dato)???
end loop;???‐‐ T(buscar(T,dato))=dato
end buscar;end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 44
![Page 45: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/45.jpg)
Paso 2 Diseñamos el código previo al buclePaso 2. Diseñamos el código previo al bucle
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
‐‐ (∃α∈[1,N].T(α)=dato)hasta := 1;
(∀ [ h t ] ( ) d t )‐‐ (∀α∈[1,hasta‐1].T(α)≠dato)while ??? loop ‐‐ Inv: (∀α∈[1,hasta‐1].T(α)≠dato)
???end loop;???
T(buscar(T dato))=dato‐‐ T(buscar(T,dato))=datoend buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 45
![Page 46: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/46.jpg)
Pasos 3 y 4 Condición del bucle y el código posteriorPasos 3 y 4. Condición del bucle y el código posterior
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
‐‐ (∃α∈[1,N].T(α)=dato)hasta := 1;hil t ( (h t ) d t ) lwhile not (T(hasta)=dato) loop‐‐ Inv: (∀α∈[1,hasta‐1].T(α)≠dato)???
end loop;‐‐ (∀α∈[1,hasta‐1].T(α)≠dato) ∧ T(hasta)=datodevuelve hasta;devuelve hasta;‐‐ T(buscar(T,dato))=dato
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 46
![Page 47: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/47.jpg)
Pasos 5 y 6 Código interior del bucle y función de cotaPasos 5 y 6. Código interior del bucle y función de cota
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐h t t I dihasta : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ (∃α∈[1,N].T(α)=dato)hasta := 1;while not (T(hasta)=dato) loop f cota = N hastawhile not (T(hasta)=dato) loop ‐‐ f_cota = N ‐ hasta
‐‐ Inv: (∀α∈[1,hasta‐1].T(α)≠dato)‐‐ (∀α∈[1,hasta‐1].T(α)≠dato) ∧ T(hasta)≠datohasta := hasta + 1; ‐‐ (∀α∈[1,hasta‐1].T(α)≠dato)
end loop;devuelve hasta;‐‐ T(buscar(T,dato))=dato
end buscar;end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 47
![Page 48: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/48.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : out tpD)
return tpIndice is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: (∃α∈[1,N].T(α)=dato)‐‐ Post: T(buscar(T,dato))=dato‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
hasta : tpIndice;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
hasta := 1;while not (T(hasta)=dato) loop
‐‐ (∀α∈[1 hasta‐1] T(α)≠dato)‐‐ (∀α∈[1,hasta‐1].T(α)≠dato)hasta := hasta + 1;
end loop;devuelve hasta;devuelve hasta;
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 48
![Page 49: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/49.jpg)
Problema 5 2 Derivar un diseño iterativo para elProblema 5.2. Derivar un diseño iterativo para elsiguiente algoritmo Ada.
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD) function buscar (T : in tpTabla; dato : in tpD)
return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
i‐‐ Pre: cierto‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)(( [ ] ( ) ) ( ( )) )‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 49
![Page 50: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/50.jpg)
Esquema del algoritmo iterativo a diseñarEsquema del algoritmo iterativo a diseñar.‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD)
return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: ciertoPre: cierto‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
???while ??? loop ‐‐ Invariante
???end loop;end loop;???
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 50
![Page 51: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/51.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice; esta : boolean;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐b ibegin
‐‐ cierto???while ??? loop
‐‐ Inv: esta=(∃α∈[1,hasta].T(α)=dato)‐‐ ∧ esta → T(hasta)=dato‐‐ ∧ esta → T(hasta)=dato???
end loop;???‐‐ (∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)(( [ , ] ( ) ) ( ( , )) )
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 51
![Page 52: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/52.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice; esta : boolean;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐b ibegin
‐‐ ciertohasta := 1; esta := T(hasta)=dato;‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=datowhile ??? loop
‐‐ Inv: esta=(∃α∈[1 hasta] T(α)=dato)‐‐ Inv: esta=(∃α∈[1,hasta].T(α)=dato)‐‐ ∧ esta → T(hasta)=dato???
end loop;???‐‐ (∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)( [ , ] ( ) ) ( , ) )‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 52
![Page 53: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/53.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice; esta : boolean;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ ciertohasta := 1; esta := T(hasta)=dato;‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=datoesta (∃α∈[1,hasta].T(α) dato) ∧ esta → T(hasta) datowhile not (hasta=N or esta) loop
‐‐ Inv: esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato??????
end loop;‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato‐‐ ∧ (hasta=N ∨ esta)‐‐ ∧ (hasta=N ∨ esta)if esta then return hasta; else return 0; end if;‐‐ (∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)
∧ ((∃α∈[1 N] T(α)=dato) → T(buscar(T dato))=dato)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 53
![Page 54: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/54.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta : tpIndice; esta : boolean;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ ciertohasta := 1; esta := T(hasta)=dato;while not (hasta=N or esta) loop ‐‐ f cota = N ‐ hastawhile not (hasta N or esta) loop f_cota N hasta
‐‐ Inv: esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato‐‐ ∧ (hasta≠N ∧ ¬esta)∧ (hasta≠N ∧ ¬esta)hasta := hasta + 1; esta := T(hasta)=dato;‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=dato
end loop;end loop;if esta then return hasta; else return 0; end if;‐‐ (∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)
∧ ((∃α∈[1 N] T(α)=dato) → T(buscar(T dato))=dato)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 54
![Page 55: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/55.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD)
return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: cierto‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)∧ ((∃α∈[1,N].T(α) dato) → T(buscar(T,dato)) dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
hasta : tpIndice; esta : boolean;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
hasta := 1; esta := T(hasta)=dato;while not (hasta=N or esta) loopwhile not (hasta=N or esta) loop
‐‐ esta=(∃α∈[1,hasta].T(α)=dato) ∧ esta → T(hasta)=datohasta := hasta + 1; esta := T(hasta)=dato;
end loop;end loop;if esta then return hasta; else return 0; end if;
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 55
![Page 56: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/56.jpg)
Problema 5 3 Derivar un diseño iterativo del siguienteProblema 5.3. Derivar un diseño iterativo del siguiente algoritmo Ada.
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD) function buscar (T : in tpTabla; dato : in tpD)
return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
( [ ] ( ) ( ))‐‐ Pre: (∀α∈[1,N‐1].T(α)≤T(α+1))‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)(( [ ] ( ) ) ( ( )) )‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
lUtilizaremos: ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))t (T d t i f ) (∃ [i f ] T( ) d t )esta(T,dato,inf,sup) = (∃α∈[inf,sup].T(α)=dato)
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 56
![Page 57: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/57.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD)
t i t ireturn integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: ordenada(T,1,N) ‐‐ Post: (¬esta(T,dato,1,N) → buscar(T,dato)=0)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Hemos utilizado los siguientes predicados:Hemos utilizado los siguientes predicados:ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))esta(T,dato,inf,sup) = (∃α∈[inf,sup].T(α)=dato)
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 57
![Page 58: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/58.jpg)
Esquema del algoritmo iterativo a diseñarEsquema del algoritmo iterativo a diseñar.‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD)
return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: (∀α∈[1,N‐1].T(α)≤T(α+1))Pre: (∀α∈[1,N 1].T(α)≤T(α+1))‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
???while ??? loop ‐‐ Invariante
???end loop;end loop;???
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 58
![Page 59: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/59.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐izda, dcha: tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ ordenada(T,1,N)???while ??? loopwhile ??? loop
‐‐ Inv: ordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)
??????end loop;???‐‐ (¬esta(T dato 1 N) → buscar(T dato)=0)‐‐ (¬esta(T,dato,1,N) → buscar(T,dato)=0)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Donde: ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))esta(T dato inf sup) (∃ [inf sup] T( ) dato)esta(T,dato,inf,sup) = (∃α∈[inf,sup].T(α)=dato)
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 59
![Page 60: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/60.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐izda, dcha: tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ ordenada(T,1,N)izda := 1; dcha := N;‐‐ ordenada(T,1,N) ∧ izda≤dchaordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)while ??? loop
‐‐ Inv: ordenada(T 1 N) ∧ izda≤dchaInv: ordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)???
end loop;end loop;???‐‐ (¬esta(T,dato,1,N) → buscar(T,dato)=0)
∧ (esta(T dato 1 N) → T(buscar(T dato))=dato)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 60
![Page 61: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/61.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐izda, dcha: tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ ordenada(T,1,N)izda := 1; dcha := N;while not (izda = dcha) loopwhile not (izda dcha) loop
‐‐ Inv: ordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)??????
end loop;‐‐ ordenada(T,1,N) ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)‐‐ ∧ izda = dcha‐‐ ∧ izda = dchaif T(izda)=dato then return izda; else return 0; end if;‐‐ (¬esta(T,dato,1,N) → buscar(T,dato)=0)
∧ (esta(T dato 1 N) → T(buscar(T dato))=dato)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 61
![Page 62: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/62.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐izda, dcha, medio: tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ ordenada(T,1,N)( , , )izda := 1; dcha := N;while not (izda = dcha) loop ‐‐ f_cota = dcha ‐ izda
‐‐ ordenada(T,1,N) ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)ordenada(T,1,N) ∧ esta(T,dato,1,N) esta(T,dato,izda,dcha)‐‐ ∧ izda<dchamedio := (izda + dcha)/2;if T(medio)<dato if T(medio)<dato then izda := medio + 1; else dcha := medio;
end if;‐‐ ordenada(T 1 N) ∧ izda≤dchaordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)
end loop;if T(izda)=dato then return izda; else return 0; end if;if T(izda)=dato then return izda; else return 0; end if;‐‐ (¬esta(T,dato,1,N) → buscar(T,dato)=0)‐‐ ∧ (esta(T,dato,1,N) → T(buscar(T,dato))=dato)
end buscar;end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 62
![Page 63: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/63.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐function buscar (T : in tpTabla; dato : in tpD) return integer isfunction buscar (T : in tpTabla; dato : in tpD) return integer is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: (∀α∈[1,N‐1].T(α)≤T(α+1))‐‐ Post: ((∀α∈[1,N].T(α)≠dato) → buscar(T,dato)=0)‐‐ ∧ ((∃α∈[1,N].T(α)=dato) → T(buscar(T,dato))=dato)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
izda, dcha, medio: tpIndice;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
izda := 1; dcha := N;while not (izda = dcha) loopwhile not (izda = dcha) loop
‐‐ ordenada(T,1,N) ∧ izda≤dcha‐‐ ∧ esta(T,dato,1,N) = esta(T,dato,izda,dcha)medio := (izda + dcha)/2;if T(medio)<dato
then izda := medio + 1; else dcha := medio; end if;
d lend loop;if T(izda)=dato then return izda; else return 0; end if;
end buscar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 63
![Page 64: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/64.jpg)
6 Aplicación al diseño de algoritmos de6. Aplicación al diseño de algoritmos de ordenación interna de una tabla
Diseñar el siguiente algoritmo Ada:
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: (∀α∈[1,N‐1].T(α)≤T(α+1)) ‐‐ ∧ (∀α∈[1,N].(Núm β∈[1,N].To(β)=To(α)) ‐‐ = (Núm β∈[1,N].T(β)=To(α))) ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Utilizaremos:Utilizaremos: ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))sonPermutacion(T1,T2,inf,sup) =
(∀α∈[inf,sup].(Núm β∈[inf,sup].T1(β)=T1(α)) = (Núm β∈[inf,sup].T2(β)=T1(α))) 64
![Page 65: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/65.jpg)
Diseñar el siguiente algoritmo Ada:Diseñar el siguiente algoritmo Ada:
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) isprocedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To
P t P t i (T T 1 N) d d (T 1 N)‐‐ Post: sonPermutacion(To,T,1,N) ∧ ordenada(T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Hemos utilizado los siguientes predicados: ordenada(T,inf,sup) = (∀α∈[inf,sup‐1].T(α)≤T(α+1))sonPermutacion(T1 T2 inf sup) =sonPermutacion(T1,T2,inf,sup) =
(∀α∈[inf,sup].(Núm β∈[inf,sup].T1(β)=T1(α)) = (Núm β∈[inf,sup].T2(β)=T1(α)))
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 65
![Page 66: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/66.jpg)
Esquema del algoritmo iterativo a diseñarEsquema del algoritmo iterativo a diseñar.‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
??????while ??? loop ‐‐ Invariante
???end loop;???
end ordenar;end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 66
![Page 67: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/67.jpg)
Problema 6 1 Diseño del algoritmo de ordenación interna porProblema 6.1. Diseño del algoritmo de ordenación interna por selección directa
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Pre: T = To‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
???while ??? loop
I ????‐‐ Inv: ???????
end loop;??????
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 67
![Page 68: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/68.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
i : integer;i : integer;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
??????while ??? loop
‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T 1 i+1) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)???
end loop;??????
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 68
![Page 69: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/69.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ T = Toi := 0;‐‐ (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))(∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)while ??? loop
‐‐ Inv: (∀α∈[1 i] (∀β∈[i+1 N] T(α)≤T(β)))Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)???
end loop;end loop;???‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 69
![Page 70: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/70.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ T = Toi := 0;‐‐ (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))(∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)while not (i = N‐1) loop
‐‐ Inv: (∀α∈[1 i] (∀β∈[i+1 N] T(α)≤T(β)))Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)???
end loop;end loop;‐‐ (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N) ∧ i = N‐1nula; la eliminamos por ser innecesarianula; ‐‐ la eliminamos por ser innecesaria‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 70
![Page 71: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/71.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer; j, iMenor : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
T T‐‐ T = Toi := 0;while not (i = N‐1) loop
‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)???while ??? loop
‐‐ InvInt: (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)???d lend loop;
???end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 71
![Page 72: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/72.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer; j, iMenor : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
T T‐‐ T = Toi := 0;while not (i = N‐1) loop
‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)i := i + 1; iMenor:= i; j := i;‐‐ (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)while ??? loop
‐‐ InvInt: (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))d d (T 1 i) P t i (T T 1 N)‐‐ ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)
???end loop;??????
end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 72
![Page 73: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/73.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer; j, iMenor : tpIndice; dato : tpD;g j p p
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ T = Toi := 0;while not (i = N‐1) loop
‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T 1 i+1) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)i := i + 1; iMenor:= i ; j := i;while not (j = N) loop
‐‐ InvInt: (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ iMenor≥i ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)???
end loop;( ( ( ) ( ))) ( ( ) ( ))‐‐ (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))
‐‐ ∧ iMenor≥i ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N) ∧ j = Ndato := T(i); T(i) := T(iMenor); T(iMenor) := dato;‐‐ (∀α∈[1 i] (∀β∈[i+1 N] T(α)≤T(β)))(∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)
end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
73
![Page 74: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/74.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : integer; j, iMenor : tpIndice; dato : tpD;g j p p
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ T = Toi := 0;while not (i = N‐1) loop ‐‐ f_cota = N ‐ i
‐‐ Inv: (∀α∈[1,i].(∀β∈[i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T 1 i+1) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,1,i+1) ∧ sonPermutacion(To,T,1,N)i := i + 1; iMenor:= i ; j := i;while not (j = N) loop ‐‐ f_cota = N ‐ j
‐‐ (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ iMenor≥i ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N) ∧ j ≠ Nj := j + 1;if T(j)<T(iMenor) then iMenor := j; end if;
( ( ( ) ( ))) ( ( ) ( ))‐‐ (∀α∈[1,i‐1].(∀β∈[i,N].T(α)≤T(β))) ∧ (∀α∈[i,j].T(iMenor)≤T(α))‐‐ ∧ iMenor≥i ∧ ordenada(T,1,i) ∧ sonPermutacion(To,T,1,N)
end loop;dato := T(i); T(i) := T(iMenor); T(iMenor) := dato;dato := T(i); T(i) := T(iMenor); T(iMenor) := dato;
end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
74
![Page 75: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/75.jpg)
Problema 6 2 Diseño del algoritmo de ordenación interna porProblema 6.2. Diseño del algoritmo de ordenación interna por intercambio directo
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Pre: T = To‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
???while ??? loop
I ???‐‐ Inv: ??????
end loop;??????
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 75
![Page 76: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/76.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
i : tpIndice;i : tpIndice;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
??????while ??? loop
‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T N‐i N) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)???
end loop;??????
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 76
![Page 77: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/77.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ T = Toi := 0;‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))(∀α∈[1,N i].(∀β∈[N i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)while ??? loop
‐‐ Inv: (∀α∈[1 N‐i] (∀β∈[N‐i+1 N] T(α)≤T(β)))Inv: (∀α∈[1,N i].(∀β∈[N i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)???
end loop;end loop;???‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 77
![Page 78: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/78.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beging
‐‐ T = Toi := 0;while not (i = N‐1) loopwhile not (i N 1) loop
‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)??????
end loop;‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T N‐i N) ∧ sonPermutacion(To T 1 N) ∧ i = N‐1‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N) ∧ i = N‐1nula; ‐‐ la eliminamos por ser innecesaria‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 78
![Page 79: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/79.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, j : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
T T‐‐ T = Toi := 0;while not (i = N‐1) loop
‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))Inv: (∀α∈[1,N i].(∀β∈[N i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)???while ??? loop
‐‐ Inv2: (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)
??????end loop;???
end loop;end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 79
![Page 80: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/80.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i j t I dii, j : tpIndice;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ T = ToT Toi := 0;while not (i = N‐1) loop
‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N) ∧ i ≠ N‐1i := i + 1; j := 0;‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))
T(j 1) (Má [1 j 1] T( ))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)while ??? loop
‐‐ Inv2: (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))Inv2: (∀α∈[1,N i+1].(∀β∈[N i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)
???end loop;???
end loop;d d (T 1 N) P t i (T T 1 N)‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ 80
![Page 81: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/81.jpg)
beginT T‐‐ T = To
i := 0;while not (i = N‐1) loop
‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))Inv: (∀α∈[1,N i].(∀β∈[N i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)i := i + 1; j := 0;while not (j = N – i) loop
‐‐ Inv2: (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)
??????end loop;‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))∧ T(j+1) (Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N) ∧ j = N ‐inula; ‐‐ la eliminamos por ser innecesaria‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)
end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end dend ordenar;
81
![Page 82: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/82.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, j : tpIndice; d : tpD;j p p ;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ T = Toi := 0;while not (i = N‐1) loop ‐‐ f_cota = N ‐ i
‐‐ Inv: (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T N‐i N) ∧ sonPermutacion(To T 1 N)‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)i := i + 1; j := 0;while not (j = N – i) loop ‐‐ f_cota = N ‐ j
‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N) ∧ i ≠ N ‐ij := j + 1;i (j) (j ) (j) (j) (j ) (j ) iif T(j)>T(j+1) then d := T(j); T(j) := T(j+1); T(j+1):= d; end if;‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T N‐i N) ∧ sonPermutacion(To T 1 N) ∧ i ≠ N ‐i∧ ordenada(T,N i,N) ∧ sonPermutacion(To,T,1,N) ∧ i ≠ N i
end loop;end loop;‐‐ ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
82
![Page 83: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/83.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) isp ( p )‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
i, j : tpIndice; d : tpD;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
i := 0;while not (i = N‐1) loop
‐‐ (∀α∈[1,N‐i].(∀β∈[N‐i+1,N].T(α)≤T(β)))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)i := i + 1; j := 0;while not (j = N – i) loop
( ( ( ) ( )))‐‐ (∀α∈[1,N‐i+1].(∀β∈[N‐i+2,N].T(α)≤T(β)))‐‐ ∧ T(j+1)=(Máx α∈[1,j+1].T(α))‐‐ ∧ ordenada(T,N‐i,N) ∧ sonPermutacion(To,T,1,N)j := j + 1;j := j + 1;if T(j)>T(j+1) then d := T(j); T(j) := T(j+1); T(j+1):= d; end if;
end loop;end loop;
end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
83
![Page 84: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/84.jpg)
Problema 6 3 Diseño del algoritmo de ordenación interna por elProblema 6.3. Diseño del algoritmo de ordenación interna por el método de ordenación rápida (quicksort) de C.A.R. Hoare
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Pre: T = To‐‐ Pre: T = To‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
???end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Se plantea un diseño por inmersión.
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 84
![Page 85: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/85.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure ordenar (T : in out tpTabla) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To
t d d ( 1 ) t i ( 1 )‐‐ Post: ordenada(T,1,N) ∧ sonPermutacion(To,T,1,N)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure quicksort (T : in out tpTabla; izda, dcha: in tpIndice) isprocedure quicksort (T : in out tpTabla; izda, dcha: in tpIndice) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To ∧ izda≤dcha‐‐ Post: ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
???d i k tend quicksort;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐beginbegin
quicksort(T, 1, N);end ordenar;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 85
![Page 86: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/86.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure quicksort (T : in out tpTabla; izda, dcha: in tpIndice) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To ∧ izda≤dcha
t d d ( i d d h ) t i ( i d d h )‐‐ Post: ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ T = To ∧ izda≤dchaT To ∧ izda≤dchaif izda<dcha then
???while ??? loop
‐‐ Inv: ??????
end loop;??????
end if;‐‐ ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)
end quicksort;end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 86
![Page 87: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/87.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, d : tpIndice; pivote : tpD;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ T = To ∧ izda≤dchaif izda<dcha then
???while ??? loopwhile ??? loop
‐‐ Inv: pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α))‐‐ ∧ sonPermutacion(To,T,izda,dcha)( , , , )???
end loop;???
end if;‐‐ ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)
end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 87
![Page 88: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/88.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, d : tpIndice; pivote : tpD;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
i d d h‐‐ T = To ∧ izda≤dchaif izda<dcha then
‐‐ T = To ∧ izda<dchapivote := T(izda); i := izda + 1; d := dcha;pivote := T(izda); i := izda + 1; d := dcha;‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α))‐‐ ∧ sonPermutacion(To,T,izda,dcha)while ??? loop
‐‐ Inv: pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α))
P t i (T T i d d h )‐‐ ∧ sonPermutacion(To,T,izda,dcha)???
end loop;??????
end if;‐‐ ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)
end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 88
![Page 89: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/89.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, d : tpIndice; pivote : tpD;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
i d d h‐‐ T = To ∧ izda≤dchaif izda<dcha then
pivote := T(izda); i := izda + 1; d := dcha;while not (i = d+1) loopwhile not (i = d+1) loop
‐‐ Inv: pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ‐‐ ∧ sonPermutacion(To,T,izda,dcha)???
end loop;‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1
(∀ [i d 1 i 1] T( ) ≤ i t ) (∀ [d 1 d h ] i t ≤ T( )) ‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ‐‐ ∧ sonPermutacion(To,T,izda,dcha) ∧ i = d+1T(izda) := T(d); T(d) := pivote; quicksort(T, izda, d‐1); quicksort(T, d+1, dcha);quicksort(T, izda, d 1); quicksort(T, d+1, dcha);‐‐ ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)
end if;‐‐ ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)
end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
MP ‐ Tema V ‐ Diseño de algoritmos iterativos correctos 89
![Page 90: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/90.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
‐‐ T = To ∧ izda≤dchaif izda<dcha then
i t T(i d ) i i d 1 d d hpivote := T(izda); i := izda + 1; d := dcha;while not (i = d + 1) loop ‐‐ f_cota = d – i + 1
‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ∧ (∀α∈[izda+1,i 1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ‐‐ ∧ sonPermutacion(To,T,izda,dcha) ∧ i ≠ d + 1 if T(i)≤pivote
then i := i + 1; elsif T(d)≥pivote then d := d – 1;else dato:= T(i); T(i) := T(d); T(d):= dato; i := i + 1; d := d – 1;
end if;i t T(i d ) i d 1 ≤ i d ≤ d h i ≤ d 1‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1
‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α)) ‐‐ ∧ sonPermutacion(To,T,izda,dcha)
end loop;end loop;T(izda) := T(d); T(d) := pivote; quicksort(T, izda, d‐1); quicksort(T, d+1, dcha);
end if;‐‐ ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)
end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ 90
![Page 91: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/91.jpg)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐procedure quicksort (T : in out tpTabla; izda, dcha: in tpIndice) is‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Pre: T = To ∧ izda≤dcha‐‐ Post: ordenada(T izda dcha) ∧ sonPermutacion(To T izda dcha)Post: ordenada(T,izda,dcha) ∧ sonPermutacion(To,T,izda,dcha)‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐i, d : tpIndice; pivote, dato : tpD;
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐begin
if izda<dcha thenpivote := T(izda); i := izda + 1; d := dcha;while not (i = d + 1) loop( ) p
‐‐ pivote = T(izda) ∧ izda+1 ≤ i ∧ d ≤ dcha ∧ i ≤ d+1‐‐ ∧ (∀α∈[izda+1,i‐1].T(α) ≤ pivote) ∧ (∀α∈[d+1,dcha]. pivote ≤ T(α))‐‐ ∧ sonPermutacion(To,T,izda,dcha)if T(i)≤pivoteif T(i)≤pivotethen i := i + 1; elsif T(d)≥pivote then d := d – 1;else dato:= T(i); T(i) := T(d); T(d):= dato; i := i + 1; d := d – 1;
end if;end loop;T(izda) := T(d); T(d) := pivote; quicksort(T, izda, d‐1); quicksort(T, d+1, dcha);quicksort(T, izda, d 1); quicksort(T, d+1, dcha);
end if;end quicksort;‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
91
![Page 92: Tema 5 Derivacion Algoritmos](https://reader035.vdocuments.mx/reader035/viewer/2022081800/56d6bf4b1a28ab301695aa23/html5/thumbnails/92.jpg)