Universidad de Cuenca

Fundamentos de Programación

Estructuras de Control
Angel Vázquez-Patiño

7 de abril de 2016

Contenido
Nombre del docente.......................................................................................................1
Tema asignado...............................................................................................................2
Vídeos............................................................................................................................2
Contenidos.....................................................................................................................2
PSeInt.......................................................................................................................2
Flujo secuencial.........................................................................................................2
Estructuras de decisión.............................................................................................3
If-Then..................................................................................................................3
If-Then-Else..........................................................................................................4
Estructuras de decisión anidadas..........................................................................4
Switch...................................................................................................................5
Estructuras de repetición..........................................................................................6
While....................................................................................................................7
Repeat-Until.........................................................................................................7
For.........................................................................................................................8
Contadores............................................................................................................9
Acumuladores......................................................................................................11
Banderas.............................................................................................................11
Lecturas adicionales.....................................................................................................12
Actividades..................................................................................................................12
Ejercicios......................................................................................................................12
Evaluaciones................................................................................................................12
Referencias...................................................................................................................12

Nombre del docente

Angel Oswaldo Vázquez Patiño
Tema asignado
Estructuras de control

Vídeos

Contenidos

PSeInt
PseInt (PSeudo Intérprete, http://pseint.sourceforge.net/) es una herramienta para
escribir el pseudocódigo y generar el diagrama de flujo de un algoritmo. La
herramienta permite centrar la atención en los conceptos fundamentales de la
algoritmia computacional, minimizando las dificultades propias de un lenguaje y
proporcionando un entorno de trabajo con numerosas ayudas y recursos didácticos.

Las figuras de diagrama de flujo y el formato de pseudocódigo presentado en PSeInt

será tomado en lo que sigue de este capítulo. Usted puede encontrar una presentación
de las funcionalidades principales de la herramienta y el desarrollo de un ejemplo
sencillo en el vídeo Presentación de PSeInt (https://youtu.be/XGSSw_Mh_fs).

Flujo secuencial
Un algoritmo de flujo secuencial es la estructura más simple e intuitiva de entender
la ejecución de una secuencia de operaciones. En esta estructura la ejecución se lleva
a cabo de acuerdo exactamente al orden presentado en el diagrama de flujo o
pseudocódigo. El siguiente pseudocódigo y respectivo diagrama de flujo representa un
algoritmo de flujo secuencial para encontrar la suma y el promedio de tres
calificaciones. Una explicación adicional de la estructura de ejecución secuencial se
puede encontrar en el vídeo Estructura de control secuencial
(https://youtu.be/Cab4VDOTGVg).

2
Proceso sumaPromedio
Leer cal1;
Leer cal2;
Leer cal3;
suma <- cal1 + cal2 + cal3;
promedio <- suma / 3;
FinProceso

Estructuras de decisión
Para la mayoría de problemas que se pretender resolver con algoritmos
computaciones es imposible utilizar sólo estructuras secuenciales. Un algoritmo
necesita bifurcar su flujo de acuerdo al valor de una variable o luego de comprobar
una condición. Las estructuras de decisión que se pueden implementar en la mayoría
de los lenguajes de programación son:

1. If-Then

2. If-Then-Else

3. Switch

If-Then
Evalúa una condición específica (una expresión booleana) y en caso de que sea
verdadera, se ejecuta la sentencia o bloque de sentencias luego de la palabra Then
(Entonces); si la condición es falsa, se ejecutan las sentencias que están a
continuación de la estructura. El siguiente pseudocódigo y respectivo diagrama de
flujo representa un algoritmo que utiliza la estructura If-Then para indicar si una
edad corresponde a una persona mayor de edad (≥18).
Proceso mayorDeEdad
Leer edad;
Si edad >= 18 Entonces
Escribir "Usted es mayor de edad.";
Fin Si
FinProceso

3
If-Then-Else
Cuando la condición es verdadera, se ejecuta la sentencia o bloque de sentencias
luego de la palabra Then, y luego se continua con las sentencias después de la
estructura If-Then-Else. Si la condición es falsa, se ejecuta la sentencia o bloque de
sentencias luego de la palabra Else, y luego se continua con las sentencias después de
la estructura If-Then-Else. El siguiente pseudocódigo y respectivo diagrama de flujo
representa un algoritmo que utiliza la estructura If-Then-Else para indicar si una
edad corresponde a una persona mayor de edad (≥18) o menor de edad.
Proceso mayorMenorDeEdad
Leer edad;
Si edad >= 18 Entonces
Escribir "Usted es mayor de edad.";
Sino
Escribir "Usted es menor de edad.";
Fin Si
FinProceso

Estructuras de decisión anidadas

Se puede utilizar cualquier tipo de sentencia tras la palabra Then o Else; incluso otra

4
estructura If-Then o If-Then-Else. Cuando una o ambas bifurcaciones de una
sentencia If-then o If-Then-Else contienen también una estructura If-Then o
If-Then-Else, se dice que la estructura corresponde a una estructura If anidada y al
proceso anidamiento (Editorial Macro, 2001, p. 32). El siguiente pseudocódigo y
respectivo diagrama de flujo representa un algoritmo que utiliza una estructura If
anidada para indicar si un número es positivo negativo o nulo.
Proceso positivoNegativoNulo
Leer num;
Si num > 0 Entonces
Escribir "Positivo.";
Sino
Si num < 0 Entonces
Escribir "Negativo.";
Sino
Escribir "Nulo.";
Fin Si
Fin Si
FinProceso

Switch
La estructura de selección múltiple Switch (llamado también Case o Select) ofrece
posibilidades similares a la estructura If-Then-Else, pero hace que el código sea más
legible. Se utiliza cuando las alternativas en una estructura básica de decisión son
más de dos. Las condiciones serán valores preestablecidos (no rangos). Hay que dejar
claro que el único beneficio que representa esta estructura de selección múltiple es la

5
legibilidad del código; toda estructura Switch puede ser escrita con varias estructuras
If con los mismos resultados. El siguiente pseudocódigo y respectivo diagrama de
flujo representa un algoritmo que utiliza una estructura de selección múltiple para
indicar con letras un día de la semana (lunes-viernes) dado como número.
Proceso diaSemana
Leer dia
Segun dia Hacer
1:
Escribir 'Lunes'
2:
Escribir 'Martes'
3:
Escribir 'Miércoles'
4:
Escribir 'Jueves'
De Otro Modo:
Escribir 'Viernes'
FinSegun
FinProceso

Estructuras de repetición
Las estructuras de repetición permiten repetir la ejecución de una o más sentencias
mientras una condición sea verdadera o hasta que una condición sea verdadera. La
mayoría de lenguajes de programación permiten utilizar las siguientes estructuras de
repetición:

1. While

2. Repeat-Until

6
 3. For

While
While permite repetir una sentencia o bloque de sentencias mientras una condición
sea verdadera (i.e., hasta que la condición sea falsa). El siguiente pseudocódigo y
respectivo diagrama de flujo representa un algoritmo que muestra el cuadrado de los
números del 1 hasta el 5.
Proceso potenciaCuadrado
i <- 1;
Mientras i <= 5 Hacer
potencia <- i*i;
Escribir potencia;
i <- i + 1;
Fin Mientras
FinProceso

Repeat-Until
Primero ejecuta una sentencia o bloque de sentencias y luego prueba la condición
después de cada ejecución. Repeat garantiza al menos una ejecución de la(s)
sentencia(s) y detiene las iteraciones cuando la condición es verdadera. El siguiente
pseudocódigo y respectivo diagrama de flujo representa un algoritmo que muestra el
cubo de los números del 1 hasta el 5.
Proceso potenciaCubo
i <- 1;

7
 Repetir
potencia <- i * i * i;
Escribir potencia;
i <- i + 1;
Hasta Que i > 5
FinProceso

For
Los bucles While y Repeat se utilizan cuando no se sabe cuántas veces se necesitará
ejecutar una sentencia o bloque de sentencias (se itera mientras o hasta que se
cumpla una condición). La estructura de repetición For se utiliza cuando se sabe
cuántas veces exactamente se va(n) a ejecutar la(s) sentencia(s). Una explicación
adicional del bucle For se puede encontrar en el vídeo Bucle For
(https://youtu.be/KCm2PNarOGs). El siguiente pseudocódigo y respectivo diagrama
de flujo representa un algoritmo que muestra el cubo de los números del -5 hasta el 5.
Proceso potenciaCubo
Para i <- -5 Hasta 5 Con Paso 1 Hacer
potencia <- i * i * i;
Escribir potencia;
Fin Para
FinProceso

8
Contadores
Contadores es el nombre que se ha dado a la utilización de una estrategia donde una
variable se incrementa con número fijo cada vez que se cumple una condición o se
realiza una iteración en un bucle. El incremento en los contadores por lo general es
de una unidad, sin embargo, es posible que el incremento sea diferente (de hecho
podría ser un decremento también). El contador se utiliza para llevar la cuenta de
determinadas acciones que se pueden solicitar durante la resolución de un problema.
En las sentencias de preparación se realiza la inicialización del contador. La
inicialización consiste en poner el valor inicial de la variable que representa al
contador. Generalmente se inicializa con el valor 0, sin embargo, dependiendo del
problema a solucionar, podría ser diferente.

Por lo general se utiliza un contador para llevar la cuenta del número de iteraciones
en un While o Repeat y así decidir cuándo terminar el bucle. En el caso de la
estructura For hay un contador implícito y se puede cambiar el incremento (o
decremento) luego de la palabra Con Paso. Los siguientes pseudocódigos y
respectivos diagramas de flujo representan un algoritmo que muestra los números
pares del 2 al 10 utilizando las estructuras de repetición While, Repeat y For; se usa
un contador un incremento de dos.

9
Proceso paresWhile
i <- 2;
Mientras i <= 10 Hacer
Escribir i;
i <- i + 2;
Fin Mientras
FinProceso

Proceso paresRepeat
i <- 2;
Repetir
Escribir i;
i <- i + 2;
Hasta Que i > 10
FinProceso

10
Proceso paresFor
Para i <- 2 Hasta 10 Con Paso 2 Hacer
Escribir i;
Fin Para
FinProceso

Acumuladores
Un acumulador es una variable que suma a su valor actual una cantidad que puede
ser variable. Se utiliza para efectuar sumas sucesivas en bucles o cuando se cumple
una condición. Se puede decir que un contador es un caso específico de acumulador
(i.e., un contador es un acumulador que suma siempre un valor, pero constante).

Banderas
Una bandera, interruptor o conmutador es una variable que durante la ejecución de
un algoritmo solamente toma uno de dos o más valores posibles. Se utilizan por lo
general para salir de un bucle de iteración variable (While o Repeat) o para variar la
secuencia de la ejecución. Se de inicializar el valor de la bandera antes de utilizarlo y
solamente se cambiará su valor cuando se cumpla una condición. El siguiente
pseudocódigo y respectivo diagrama de flujo representa un algoritmo que muestra los
números pares del 2 al 10 utilizando la estructura de repetición For.
Proceso paresFor
bandera <- 0;
Para i <- 1 Hasta 11 Con Paso 1 Hacer
Si bandera = 1 Entonces
Escribir i;
bandera <- 0;
Sino
bandera <- 1;
FinSi
Fin Para
FinProceso

11
Lecturas adicionales
Se recomienda leer la sección 2.1 Estructuras de Control del libro de De Giusti
(2001).

Actividades

Ejercicios
Se recomienda realizar los ejercicios del capítulo 4 Sentencias de Control: Parte I del
libro de Deitel y Deitel (2012).

Evaluaciones

Referencias
De Giusti, A., 2001. Algoritmos, datos y programas con aplicaciones en Pascal,
Delphi y Visual Da Vinci, 1st ed. Pearson Educación, Buenos Aires,
Argentina.
Deitel, P.J., Deitel, H.M., 2012. Java: How to Program, 9th ed. Prentice Hall, Upper
Saddle River, N.J.
Editorial Macro, 2001. Turbo Pascal 7.0 Paso a Paso. Editorial Macro, Lima, Perú.

12
13