PROGRAMACIN ESTRUCTURADA

La programacin estructurada (en adelante simplemente PE ), es un estilo

de programacin con el cual el programador elabora programas, cuya
estructura es la ms clara posible, mediante el uso de tres estructuras
bsicas de control lgico, a saber :

a. SECUENCIA.
b. SELECCIN O INSTRUCCIN CONDICIONAL.
c. ITERATIVA O REPETITIVA.

Un programa estructurado se compone de funciones,segmentos, mdulos

y/o subrutinas, cada una con una sola entrada y una sola salida. Cada uno
de estos mdulos (an en el mismo programa completo), se denomina
programa apropiado cuando, adems de estar compuesto solamente por las
tres estructuras bsicas, tiene slo una entrada y una salida y en ejecucin
no tiene partes por las cuales nunca pasa ni tiene ciclos infinitos.
La PE tiene un teorema estructural o teorema fundamental, el cual afirma
que cualquier programa, no importa el tipo de trabajo que ejecute, puede
ser elaborado utilizando nicamente las tres estructuras bsicas
( secuencia, seleccin, iteracin ).

DEFINICIN DE LAS ESTRUCTURAS BSICAS DE CONTROL

LGICO

1.- SECUENCIA

Indica que las instrucciones de un programa se ejecutan una despus de la

otra, en el mismo orden en el cual aparecen en el programa. Se representa
grficamente como una caja despus de otra, ambas con una sola entrada y
una nica salida.

Las cajas A y B pueden ser definidas para ejecutar desde una simple
instruccin hasta un mdulo o programa completo, siempre y cuando que
estos tambin sean programas apropiados.

EJEMPLO:

Programa que lea dos nmeros por teclado y los muestre por pantalla.
2.- SELECCIN O INSTRUCCIN CONDICIONAL.

Tambin conocida como la estructura SI-CIERTO-FALSO, plantea la seleccin

entre dos alternativas con base en el resultado de la evaluacin de una
condicin o predicado; equivale a la instruccin IF de todos los lenguajes de
programacin y se representa grficamente de la siguiente manera :

En el diagrama de flujo anterior, C es una condicin que se evala; A es la

accin que se ejecuta cuando la evaluacin de este predicado resulta
verdadera y B es la accin ejecutada cuando indica falso. La estructura
tambin tiene una sola entrada y una sola salida; y las funciones A y B
tambin pueden ser cualquier estructura bsica o conjunto de estructuras.
Puede ser del tipo:
- Condicional simple: if
- Condicional doble: if ... else ...
- Condicional mltiple: if .. else if ..

Condicional simple:
La condicin debe ser una expresion booleana es decir debe dar como resultado
un valor booleano (true false).
Condicional simple: se evala la condicin y si sta se cumple se ejecuta una
determinada accin o grupo de acciones. En caso contrario se saltan dicho grupo de
acciones.
if(expresin_booleana){
instruccin 1
instruccin 2
.......
}
EJEMPLO:
PROGRMA QUE INDIQUE SI EL NUMERO ES MAYOR O IGUAL QUE 5
Condicional doble: Se evala la condicin y si sta se cumple se ejecuta una
determinada instruccin o grupo de instrucciones. Si no se cumple se ejecuta otra
instruccin o grupo de instrucciones.
if(expresin booleana){
instrucciones 1
}
else{
instrucciones 2
}
Ejemplo de programa Java que contiene una estructura condicional doble: Programa
que lee la nota de un alumno y muestra si el alumno ha aprobado o no.

/*
* Programa que pide una nota por teclado y muestra si se ha aprobado o no
*/
import java.util.*;
public class Ejemplo0If {
public static void main( String[] args ){
Scanner sc = new Scanner( System.in );
System.out.print("Nota: ");
int nota = sc.nextInt();
if (nota >= 5 ){
System.out.println("Enorabuena!!");
System.out.println("Has aprobado");
}
else
System.out.println("Lo Siento, has suspendido");
}
}

Otro ejemplo de programa Java que contiene una estructura condicional doble:
Calcular si un nmero es par. El programa lee un nmero por teclado y muestra un
mensaje indicando si es par o impar.

/*
* programa que pide un nmero por teclado y calcula si es par o impar
*/
import java.util.*;
public class EjemploIf {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num;
System.out.println("Introduzca numero: ");
num = sc.nextInt();
if ((num%2)==0)
System.out.println("PAR");
else
System.out.println("IMPAR");
}
}
Condicional mltiple: Se obtiene anidando sentencias if ... else. Permite construir
estructuras de seleccin ms complejas.
if (expresion_booleana1)
instruccion1;
else if (expresion_booleana2)
instruccion2;
else
instruccion3;
Cada else se corresponde con el if ms prximo que no haya sido emparejado.
Una vez que se ejecuta un bloque de instrucciones, la ejecucin contina en la
siguiente instruccin que aparezca despus de las sentencias if .. else anidadas.

Ejemplo de programa Java que contiene una estructura condicional mltiple:

Programa que lee una hora (nmero entero) y muestra un mensaje segn la hora
introducida.
/*
* Programa que muestra un saludo distinto segn la hora introducida
*/
import java.util.*;
public class Ejemplo2If {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int hora;
System.out.println("Introduzca una hora (un valor entero): ");
hora = sc.nextInt();
if (hora >= 0 && hora < 12)
System.out.println("Buenos das");
else if (hora >= 12 && hora < 21)
System.out.println("Buenas tardes");
else if (hora >= 21 && hora < 24)
System.out.println("Buenas noches");
else
System.out.println("Hora no vlida");
}
}

Ejemplo de programa Java que contiene una estructura condicional mltiple:

Programa que lee una nota (nmero entero entre 0 y 10) y muestra la calificacin
equivalente en forma de texto.

/*
* programa que lee una nota y escribe la calificacin correspondiente
*/
import java.util.*;
public class Ejemplo3If {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double nota;
System.out.println("Introduzca una nota entre 0 y 10: ");
nota = sc.nextDouble();
System.out.println("La calificacin del alumno es ");
if(nota < 0 || nota > 10)
System.out.println("Nota no vlida");
else if(nota==10)
System.out.println("Matrcula de Honor");
else if (nota >= 9)
System.out.println("Sobresaliente");
else if (nota >= 7)
System.out.println("Notable");
 else if (nota >= 6)
System.out.println("Bien");
else if (nota >= 5)
System.out.println("Suficiente");
else
System.out.println("Suspenso");
}
}

3.- ESTRUCTURA ITERATIVA O REPETITIVA

Tambin llamada la estructura HACER-MIENTRAS-QUE, corresponde a la

ejecucin repetida de una instruccin mientras que se cumple una
determinada condicin. El diagrama de flujo para esta estructura es el
siguiente :

Aqu el bloque A se ejecuta repetidamente mientras que la condicin C se

cumpla o sea cierta. Tambin tiene una sola entrada y una sola salida;
igualmente A puede ser cualquier estructura bsica o conjunto de
estructuras.

Permiten ejecutar de forma repetida un bloque especfico de instrucciones.

Las instrucciones se repiten mientras o hasta que se cumpla una determinada
condicin. Esta condicin se conoce como condicin de salida.
Tipos de estructuras repetitivas:
- ciclo while
- ciclo do while
- ciclo for
3.1 CICLO WHILE
Las instrucciones se repiten mientras la condicin sea cierta. La condicin se
comprueba al principio del bucle por lo que las acciones se pueden ejecutar 0
ms veces.

La ejecucin de un bucle while sigue los siguientes pasos:

1. Se evala la condicin.
2. Si el resultado es false las instrucciones no se ejecutan y el programa sigue
ejecutndose por la siguiente instruccin a continuacin del while.
3. Si el resultado es true se ejecutan las instrucciones y se vuelve al paso 1

Ejemplo de programa Java que contiene una instruccin while:

Programa que lee nmeros por teclado. La lectura acaba cuando el nmero introducido
sea
negativo. El programa calcula y muestra la suma de los nmeros ledos.

/*
* Programa que lee nmeros hasta que se lee un negativo y muestra la
* suma de los nmeros ledos
*/
import java.util.*;
public class Ejemplo1While {
public static void main(String[] args) {
int suma = 0, num;
Scanner sc = new Scanner(System.in);
System.out.print("Introduzca un nmero: ");
num = sc.nextInt();
while (num >= 0){
suma = suma + num;
System.out.print("Introduzca un nmero: ");
num = sc.nextInt();
}
System.out.println("La suma es: " + suma );
}
}
Ejemplo de programa Java que contiene una instruccin while:
Programa que lee un nmero entero N y muestra N asteriscos.

/*
* programa que lee un nmero n y muestra n asteriscos
*/
import java.util.*;
public class Ejemplo2While {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n, contador = 0;
System.out.print("Introduce un nmero: ");
n = sc.nextInt();
while (contador < n){
System.out.println(" * ");
contador++;
}
}
}
 Ejemplo de programa Java con una instruccin while:

/*
* programa que muestra una tabla de equivalencias entre
* grados Fahrenheit y grados celsius
*/
public class Ejemplo3While {
public static void main(String[] args) {
final int VALOR_INICIAL = 10; // limite inf. tabla
final int VALOR_FINAL = 100; // limite sup. tabla
final int PASO = 10 ; // incremento
int fahrenheit;
double celsius;
fahrenheit = VALOR_INICIAL;
System.out.printf("Fahrenheit \t Celsius \n");
while (fahrenheit <= VALOR_FINAL ){
celsius = 5*(fahrenheit - 32)/9.0;
System.out.printf("%7d \t %8.3f \n", fahrenheit, celsius);
fahrenheit += PASO;
}
}
}

3.2 CICLO DO WHILE

Las instrucciones se ejecutan mientras la condicin sea cierta.
La condicin se comprueba al final del bucle por lo que el bloque de instrucciones
se ejecutarn al menos una vez. Esta es la diferencia fundamental con la
instruccin while. Las instrucciones de un bucle while es posible que no se ejecuten
si la condicin inicialmente es falsa.
La ejecucin de un bucle do - while sigue los siguientes pasos:
1. Se ejecutan las instrucciones a partir de do{
2. Se evala la condicin.
3. Si el resultado es false el programa sigue ejecutndose por la siguiente instruccin a
continuacin del while.
4. Si el resultado es true se vuelve al paso 1
Ejemplo de programa Java que contiene una instruccin do while:
Programa que lee un nmero entero N. El nmero debe ser menor que 100.
 /*
* Programa que obliga al usuario a introducir un nmero menor que 100
*/
import java.util.*;
public class Ejemplo1DoWhile {
public static void main(String[] args) {
int valor;
Scanner in = new Scanner( System.in );
do {
System.out.print("Escribe un entero < 100: ");
valor = in.nextInt();
}while (valor >= 100);
System.out.println("Ha introducido: " + valor);
}
}

Ejemplo de programa Java con una instruccin do while:

/*
* Programa que lee un nmero entre 1 y 10 ambos incluidos
*/
import java.util.*;
public class Ejemplo2DoWhile {
public static void main(String[] args) {
int n;
Scanner sc = new Scanner( System.in );
do {
System.out.print("Escribe un nmero entre 1 y 10: ");
n = sc.nextInt();
}while (n<1 || n >10);
System.out.println("Ha introducido: " + n);
}
}
3.3 CICLO FOR
Hace que una instruccin o bloque de instrucciones se repitan un nmero
determinado de veces mientras se cumpla la condicin.
La estructura general de una instruccin for en Java es la siguiente:
for(inicializacin; condicin; incremento/decremento){
instruccin 1;
...........
instruccin N;
}
A continuacin de la palabra for y entre parntesis debe haber siempre tres zonas
separadas por punto y coma:
- zona de inicializacin.
- zona de condicin
- zona de incremento decremento.
Si en alguna ocasin no es necesario escribir alguna de ellas se pueden dejar en
blanco, pero los dos punto y coma deben aparecer.
Inicializacin es la parte en la que la variable o variables de control del bucle
toman su valor inicial. Puede haber una o ms instrucciones en la inicializacin,
separadas por comas. La inicializacin se realiza solo una vez.
Condicin es una expresin booleana que hace que se ejecute la sentencia o
bloque de sentencias mientras que dicha expresin sea cierta. Generalmente en la
condicin se compara la variable de control con un valor lmite.
Incremento/decremento es una expresin que decrementa o incrementa la
variable de control del bucle.
La ejecucin de un bucle for sigue los siguientes pasos:
1. Se inicializa la variable o variables de control (inicializacin)
2. Se evala la condicin.
3. Si la condicin es cierta se ejecutan las instrucciones. Si es falsa, finaliza la
ejecucin del bucle y contina el programa en la siguiente instruccin despus del
for.
4. Se actualiza la variable o variables de control (incremento/decremento)
5. Se vuelve al punto 2.
Ejemplo de programa Java que contiene una instruccin for:
/*
* programa que muestra los nmeros del 1 al 10
*/
public class Ejemplo0For {
public static void main(String[] args) {
int i;
for(i=1; i<=10;i++)
System.out.println(i + " ");
}}
La instruccin for del ejemplo anterior la podemos interpretar as:
Asigna a i el valor inicial 1, mientras que i sea menor o igual a 10 muestra i + , a
continuacin incrementa el valor de i y comprueba de nuevo la condicin.
Ejemplo de programa Java con una instruccin for:
/*
* programa que muestra los nmeros del 10 al 1
*/
public class Ejemplo2For {
public static void main(String[] args) {
int i;
for(i=10; i>0;i--)
System.out.println(i + " ");
}
}
Ejemplo de programa Java con una instruccin for:
/*
* programa que muestra una tabla de equivalencias entre
* grados Fahrenheit y grados celsius
*/
public class Ejemplo1For {
public static void main(String[] args) {
final int VALOR_INICIAL = 10; // limite inf. tabla
final int VALOR_FINAL = 100; // limite sup. tabla
final int PASO = 10 ; // incremento
int fahrenheit;
double celsius;
fahrenheit = VALOR_INICIAL;
System.out.printf("Fahrenheit \t Celsius \n");
for (fahrenheit = VALOR_INICIAL; fahrenheit <= VALOR_FINAL;
fahrenheit+= PASO) {
celsius = 5*(fahrenheit - 32)/9.0;
System.out.printf("%7d \t %8.3f \n", fahrenheit, celsius);
}
}
}

En las zonas de inicializacin e incremento/decremento puede aparecer ms de una

variable. En ese caso deben ir separadas por comas.
Ejemplo:
/*
 * programa que muestra el valor de a, b y su suma mientras que la suma de
* ambas es menor de 10. En cada iteracin el valor de a se incrementa en
* 1 unidad y el de b en 2
*/
public class Ejemplo3For {
public static void main(String[] args) {
int a, b;
for(a = 1, b = 1; a + b < 10; a++, b+=2){
System.out.println("a = " + a + " b = " + b + " a + b = " + (a+b));
}
}
}
La salida de este programa es:
a=1 b=1 a+b=2
a=2 b=3 a+b=5
a=3 b=5 a+b=8
Aunque la instruccin repetitiva for, al igual que las instrucciones while y do- while,
se puede utilizar para realizar repeticiones cuando no se sabe a priori el nmero de
pasadas por el bucle, esta instruccin es especialmente indicada para bucles donde
se conozca el nmero de pasadas.
Como regla prctica podramos decir que las instrucciones while y do-while se
utilizan generalmente cuando no se conoce a priori el nmero de pasadas, y la
instruccin for se utiliza generalmente cuando s se conoce el nmero de pasadas.
Se ha de tener cuidado con escribir el punto y coma (;) despus del parntesis final
del bucle for. Un bucle for generalmente no lleva punto y coma final.
Por ejemplo el bucle:
int i;
for (i = 1; i <= 10; i++);
{
System.out.println("Elementos de Programacin");
}
no visualiza la frase "Elementos de Programacin" 10 veces, ni produce un mensaje
de error por parte del compilador.
En realidad lo que sucede es que se visualiza una vez la frase "Elementos de
Programacin", ya que aqu la sentencia for es una sentencia vaca al terminar con
un punto y coma (;).
La sentencia for en este caso hace que i empiece en 1 y acabe en 11 y tras esas
iteraciones, se ejecuta la sentencia
System.out.println("Elementos de Programacin");
3.4 BUCLES INFINITOS EN JAVA
Java permite la posibilidad de construir bucles infinitos, los cuales se ejecutarn
indefinidamente, a no ser que provoquemos su interrupcin. Tres ejemplos:

for(;;){
instrucciones
}
for(;true;){
instrucciones
}
while(true){
instrucciones
}
3.5 BUCLES ANIDADOS
Bucles anidados son aquellos que incluyen instrucciones for, while o do-while unas
dentro de otras.
Debemos tener en cuenta que las variables de control que utilicemos deben ser
distintas.
Los anidamientos de estructuras tienen que ser correctos, es decir, que una
estructura anidada dentro de otra lo debe estar totalmente.
Ejemplo de programa Java con bucles anidados:
/*
* Programa que dibuja un rectngulo slido de asteriscos.
* El nmero de filas y columnas se pide por teclado
*/
import java.util.*;
public class Ejemplo1BuclesAnidados {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int filas, columnas;
//leer nmero de filas hasta que sea un nmero > 0
do{
System.out.print("Introduce nmero de filas: ");
filas = sc.nextInt();
}while(filas<1);
//leer nmero de columnas hasta que sea un nmero > 0
do{
System.out.print("Introduce nmero de columnas: ");
columnas = sc.nextInt();
}while(columnas<1);
for(int i = 1; i<=filas; i++){ //filas
for(int j = 1; j<=columnas; j++){ //columnas
System.out.print(" * ");
}
System.out.println();
}
}
}
La salida de este programa para filas = 6 y columnas = 10 es:
* * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * *
Ejemplo de programa Java con bucles anidados:
/*
* Programa que muestra una tabla con las potencias de x (x x2 x3 x4)
* para valores de x desde 1 hasta XMAX
 */
public class JavaApplication22 {
public static void main(String[] args) {
final int XMAX = 10;
int x, n;
//mostrar la cabecera de la tabla
System.out.printf("%10s%10s%10s%10s%n", "x","x^2","x^3","x^4");
for (x = 1; x <= XMAX; x++){ //filas
for (n = 1; n <= 4; n++){ //columnas
System.out.printf("%10.0f", Math.pow(x,n));
}
System.out.println();
}}}

El programa muestra por pantalla la siguiente tabla de potencias:

x x^2 x^3 x^4
1 1 1 1
2 4 8 16
3 9 27 81
4 16 64 256
5 25 125 625
6 36 216 1296
7 49 343 2401
8 64 512 4096
9 81 729 6561
10 100
1000 10000

VENTAJAS DE LA PROGRAMACIN ESTRUCTURADA

Con la PE, elaborar programas de computador sigue siendo una labor que
demanda esfuerzo, creatividad, habilidad y cuidado. Sin embargo, con este
nuevo estilo podemos obtener las siguientes ventajas:

1. Los programas son ms fciles de entender. Un programa estructurado

puede ser ledo en secuencia, de arriba hacia abajo, sin necesidad de estar
saltando de un sitio a otro en la lgica, lo cual es tpico de otros estilos de
programacin. La estructura del programa es ms clara puesto que las
instrucciones estn ms ligadas o relacionadas entre si, por lo que es ms
fcil comprender lo que hace cada funcin.

2. Reduccin del esfuerzo en las pruebas. El programa se puede tener listo

para produccin normal en un tiempo menor del tradicional; por otro lado, el
seguimiento de las fallas o depuracin (debugging) se facilita debido a la
lgica ms visible, de tal forma que los errores se pueden detectar y corregir
ms fcilmente.

3. Reduccin de los costos de mantenimiento.

4. Programas ms sencillos y ms rpidos.

5. Aumento en la productividad del programador.

6. Se facilita la utilizacin de las otras tcnicas para el mejoramiento de la

productividad en programacin.
7. Los programas quedan mejor documentados internamente.