UNIVERSIDAD TECNOLÓGICA

DE MÉXICO

ING. SOFTWARE Y REDES

ENTREGABLE

ESTRUCTURA DE DATOS

ALUMNO:

MATRICULA:

PROFESOR:

FECHA:

1
Contenido
DESARROLLO......................................................................................................................................2
INTRODUCCION A LA PROGRAMACION ESTRUCTURADA...................................................................2
PROGRAMACION ESTRUCTURADA.................................................................................................2
TEOREMA DE BÖHM Y JACOPINI....................................................................................................2
CONTROL DE FLUJO DE UN PROGRAMA........................................................................................2
ESTRUCTURA SECUENCIAL.............................................................................................................2
ESTRUCTURA SELECTIVA................................................................................................................2
Simple.........................................................................................................................................2
Doble..........................................................................................................................................2
Múltiple......................................................................................................................................2
ESTRUCTURA REPETITIVA...............................................................................................................2
Mientras.....................................................................................................................................2
Hacer-mientras...........................................................................................................................2
Hasta..........................................................................................................................................2
Desde.........................................................................................................................................2
ESTRUCTURA ANIDADA..................................................................................................................2
SENTENCIAS DE SALTO...................................................................................................................2
CONCLUSION..................................................................................................................................2

2
DESARROLLO
INTRODUCCION A LA PROGRAMACION ESTRUCTURADA

PROGRAMACION ESTRUCTURADA
La programación estructurada es un conjunto de técnicas para desarrollar algoritmos fáciles de
escribir, verificar, leer y modificar la cual utiliza:

Diseño descendente: Consiste en diseñar los algoritmos en etapas, yendo de los conceptos
generales a los de detalle.

Recursos abstractos: En cada descomposición de una acción compleja se supone que todas las
partes resultantes están ya resueltas, posponiendo su realización para el siguiente refinamiento.

Estructuras básicas: Los algoritmos deberán ser escritos utilizando únicamente tres tipos de
estructuras básicas.

TEOREMA DE BÖHM Y JACOPINI

El teorema de Böhm y Jacopini dice que un programa propio puede ser escrito utilizando
únicamente tres tipos de estructuras: secuencial, selectiva y repetitiva.

Un programa se define como propio si cumple las siguientes características:

 Tiene un solo punto de entrada y uno de salida.

 Toda acción del algoritmo es accesible, es decir, existe al menos un camino que va desde
el inicio hasta el fin del algoritmo, se puede seguir y pasa a través de dicha acción.
 No posee lazos o bucles infinitos.

CONTROL DE FLUJO DE UN PROGRAMA

Las estructuras de selección se utilizan para seleccionar las sentencias que se han de ejecutar a
continuación y las estructuras de repetición (repetitivas o iterativas) se utilizan para repetir un
conjunto de sentencias.

Las sentencias de selección son: si (if) y según-sea (switch); las sentencias de repetición o
iterativas son: desde (for), mientras (while), hacer-mientras (do-while) o repetir-hasta que
(repeat-until); las sentencias de salto incluyen interrumpir (break), continuar (continue), ir-a
(goto), volver (return) y lanzar (trhow).

3
ESTRUCTURA SECUENCIAL

Una estructura secuencial es aquella en la cual una acción se ejecuta detrás de otra. El flujo del
programa coincide con el orden físico en el que se sitúan las instrucciones.

ESTRUCTURA SELECTIVA

Una estructura selectiva es aquella en que se ejecutan unas acciones u otras según se cumpla o no
una determinada condición. La selección puede ser simple, doble o múltiple.

Simple
Se evalúa la condición y si ésta da como resultado verdad se ejecuta una determinada acción o
grupo de acciones; en caso contrario se saltan dicho grupo de acciones.

4
Doble
Cuando el resultado de evaluar la condición es verdad se ejecutará una determinada acción o
grupo de acciones y si el resultado es falso otra acción o grupo de acciones diferentes.

Múltiple
Se ejecutarán unas acciones u otras según el resultado que se obtenga al evaluar una expresión.
Aunque la flexibilidad de esta estructura está muy condicionada por el lenguaje, en nuestro
pseudocódigo se considera que dicho resultado ha de ser de un tipo ordinal.

Cada grupo de acciones se encontrará ligado con: un valor, varios valores separados por comas, un
rango, expresado como valor _ inicial - valor _final o una mezcla de valores y rangos.

Cuando el valor obtenido al evaluar la expresión no está presente en ninguna lista de valores se
ejecutarán las acciones establecidas en la cláusula si_no, si existe dicha cláusula.

5
ESTRUCTURA REPETITIVA

Las acciones del cuerpo del bucle se repiten mientras o hasta que se cumpla una determinada
condición. Es frecuente el uso de contadores o banderas para controlar un bucle. También se
utilizan con esta finalidad los centinelas.

Un centinela es un valor específico predefinido dado a una variable que permite detectar cuándo
se desea terminar de repetir las acciones que constituyen el cuerpo del bucle.

Podemos considerar tres tipos básicos de estructuras repetitivas: mientras, hacer-mientras, hasta,
desde.

Mientras
Lo que caracteriza este tipo de estructura es que las acciones del cuerpo del bucle se realizan
cuando la condición es cierta.

Hacer-mientras
El bucle hacer-mientras es análogo al bucle mientras desde el punto de vista de que el cuerpo del
bucle se ejecuta una y otra vez mientras la condición (expresión booleana) es verdadera.

El cuerpo del bucle siempre se ejecuta, al menos una vez, incluso aunque la expresión booleana
sea falsa. Este tipo de bucle es típico de C/C++, Java o C#, pero no está presente en todos los
lenguajes de programación.

6
Hasta
Las acciones del interior del bucle se ejecutan una vez y continúan repitiéndose mientras que la
condición sea falsa.

Desde
Se utiliza cuando se conoce, con anterioridad a que empiece a ejecutarse el bucle, el número de
veces que se va a iterar. La estructura desde comienza con un valor inicial de la variable índice y las
acciones especificadas se ejecutan a menos que el valor inicial sea mayor que el valor final.

7
ESTRUCTURA ANIDADA

Tanto las estructuras selectivas como las repetitivas pueden ser anidadas, e introducidas unas en
el interior de otras.

Es posible anidar cualquier tipo de estructura repetitiva. Si se anidan dos estructuras desde, para
cada valor de la variable índice del ciclo externo se debe ejecutar totalmente el bucle interno.

Las acciones que componen el cuerpo del bucle más interno se ejecutarán el siguiente número de
veces:

SENTENCIAS DE SALTO

Las sentencias de salto hacen que el flujo de control salte a otra parte del programa. Las
sentencias de salto o bifurcación que se encuentran en los lenguajes de programación, tanto
tradicionales como nuevos (Pascal, C, C++, C#, Java, etc.) son: ir-a (goto), interrumpir (break) ,
continuar (continue), devolver (return) y lanzar (trhow).

Interrumpir (break): Uno de sus usos es interrumpir un bucle en un lugar determinado del cuerpo
de este, en vez de esperar que termine de modo natural.

Continuar (continue): Que hace que el flujo de ejecución salte el resto de un cuerpo del bucle para
continuar con la siguiente iteración, pero no interrumpe el bucle.

8
Ir-a (goto): Transfiere la ejecución del programa a una posición especificada por el programador.

La sentencia break hace que switch se abandone tras la ejecución de las acciones asociadas a un
determinado valor (situación por defecto en nuestro pesudo código en las sentencias según sea
sin necesidad de especificar interrumpir). La instrucción goto se utiliza en switch con la finalidad
de transferir el control a otro punto, de forma que, después de ejecutadas las acciones asociadas a
un valor, se ejecuten las asociadas a otro o las especificadas en la cláusula default (si_no).

CONCLUSION

En conclusión la programación estructurada son técnicas con los cuales puedes desarrollar
algoritmos fáciles de escribir la cual utiliza: Diseño descendente, Recursos abstractos, Estructuras
básicas.

El teorema de Böhm y Jacopini la programación se puede escribir en tres tipos de estructuras las
cuales son secuencial, selectiva y repetitiva.

En la estructura secuencial es aquella la cual se ejecuta una acción detrás de otra.

La estructura selectiva es aquella en que se ejecutan acciones y puede ser simple, doble o
múltiple.

Dentro de estructura repetitiva podemos considerar tres tipos básicos de estructuras: mientras,
hacer-mientras, hasta, desde.

9
Programa 4.2

10
11