Diagrama de Flujo

El Diagrama de Flujo es un esquema con diversos componentes que nos permite representar gráficamente un algoritmo.

Cada componente del diagrama de flujo simboliza una instrucción del algoritmo y está conectado con los demás componentes mediante flechas que indican la línea de ejecución de las instrucciones de principio a fin. El diagrama de flujo viene siendo otra forma de ver el algoritmo.

■ Ejemplo

La imagen de arriba ejemplifica un Diagrama de Flujo muy simple, como puede observarse cada instrucción se encuentra dentro de una figura, ya sea una elipse, rombo, rectángulo, etc., éstas figuras son los componentes del diagrama y dependen del tipo de instrucción a la que representen.

■ Componentes

► El diagrama de flujo involucra diversos componentes gráficos, entre los más comunes están:

• Óvalo > Inicio o final del algoritmo

• Romboide > Mensaje en pantalla

• Rectángulo > Instrucción

• Rombo > Condición Si/No

• Flecha > Flujo de instrucciones



■ Generación del Diagrama de Flujo con PSeInt

PSeInt es un programa que nos permite escribir nuestros algoritmos en pseudocódigo y probarlos, al mismo tiempo el programa nos proporciona de forma automática el diagrama de flujo de nuestro algoritmo. (Para más detalles véase PSeInt)

■ Estructura de un Procedimiento en Pascal

Un Procedure es un método que no devuelve ningún valor, sirve para ejecutar un conjunto de instrucciones con el simple hecho de invocarlo cuando se requiera.

■ Estructura en Pascal

Procedure Nombre();
Uses Librerías a utilizar;
Var
     //Variables
Begin
     // Conjunto de instrucciones
     //        o cuerpo
     //     del procedure
End;

Su estructura es similar a la de un programa en Pascal, así como el programa requiere un nombre: "Program Nombre;", el procedimiento también: "Procedure Nombre;". En caso de contener parámetros, éstos irían dentro de los parentesis: "Procedure Nombre(parámetros);".

También es necesario un "Uses", dependiendo de las librerías que se utilicen, un "Var" para las variables 'locales' involucradas (las pertenecientes al procedimiento), un Begin y End; (con 'punto y coma'), que indican el inicio y fin del procedimiento.

La ventaja del Procedure es que nos permite llamar un segmento de instrucciones que necesitemos en distintas partes del programa sin tener que reescribirlas todas cada vez que las ocupemos, ya que al estar contenidas dentro del Procedure basta con solo llamar a éste.

■ Ejemplo

• Sin parámetros

Procedure que solo muestra el mensaje "Hola mundo".

Procedure Hola;

Begin

     Write ('Hola mundo!...');

End;

• Con parámetros

Procedure que suma dos números.

Procedure Sumar(num1, num2 : integer);

Var

     suma : integer;

Begin

     suma := num1 + num2;

     Write ('La suma es: ',suma);

End;

■ Recorrido de un Arreglo

■ Recorrido de un arreglo, explicación:
     • Unidimensional
     • Bidimensional


■ Unidimensional

• Declaración del arreglo:
     numeros : array[1..10] of integer;

• Recorrido del arreglo:
     for i:=1 to 10 do
          WriteLn (numeros[i]);


■ Bidimensional

• Declaración de la matriz:
     numeros : array[1..10, 1..10] of integer;

• Recorrido de la matriz:
     for i:=1 to 10 do
          for j:=1 to 10 do
               WriteLn (numeros[i,j]);

Como puede observarse, para recorrer el arreglo unidimensional es necesario solo un ciclo, en este caso un "for" que inicia en el primer elemento del arreglo y se repite hasta el último elemento, en el caso del arreglo bidimensional (matriz) son necesarios dos ciclos anidados, es decir, uno dentro del otro, ya que el primer ciclo recorrerá las filas del arreglo mientras que el segundo recorrerá las columnas del mismo.

■ Arreglos Bidimensionales en Pascal

Sintaxis para la declaración de Arreglos Bidimensionales en Pascal


■ Estructura
nombre_Arreglo : array[tamaño_filas, tamaño_columnas] of tipo;

En el caso de los arreglos simples (unidimensionales) solo se requiere un parámetro como tamaño del arreglo, pero para los arreglos bidimensionales son necesarios dos, como se muestra en la estructura de declaración anterior.

Uno es el 'tamaño_filas' que indica cuantas filas contendrá el arreglo; y el otro 'tamaño_columnas' que indica cuantas columnas tendrá el arreglo o matriz.

■ Ejemplo

Un arreglo de números enteros de tamaño 5 filas por 5 columnas (5x5) en Pascal sería de la siguiente forma:

miArreglo : array[1..5, 1..5] of integer;

► De igual forma para arreglos de otros tipos como decimales o cadenas de caracteres:

miArreglo : array[1..5, 1..5] of real;
miArreglo : array[1..5, 1..5] of string;


■ Tamaño

El tamaño del arreglo no necesariamente tiene que ser igual en filas como en columnas, éstos pueden ser diferentes, por ejemplo:

[1..5, 1..10]  : 5 filas por 10 columnas
[1..3, 1..100] : 3 filas por 100 columnas

El tamaño del arreglo será según lo requiera el usuario.

Pseudocódigo 11 ► Elevar un número al cuadrado

■ Ejercicio 11: Leer y obtener el cuadrado de un número

Variables
      num, cuadrado tipo entero
Empieza
     Escribe "Ingresa número"
     Leer num
     cuadrado <- num * num
     Escribe "El cuadrado es: ",cuadrado
Fin


■ En PSeInt

Proceso Ej_11
     Escribir "Ingresa número"
     Leer num
     cuadrado <- num * num
     Escribir "El cuadrado es: ",cuadrado
FinProceso


■ Diagrama de flujo

■ En este ejemplo el cuadrado del número se obtiene multiplicándolo por si mismo y guardando el resultado en otra variable.

Esta forma es muy básica y puede aplicarse tanto en pseudocódigo como en cualquier Lenguaje de Programación, aunque éstos cuentan con funciones matemáticas especiales para este tipo de casos, por ejemplo:

Pascal :

     cuadrado := sqr(numero);
     cuadrado := pow(numero, 2);

Java:
     cuadrado := math.pow(numero, 2);

C#:
     cuadrado := Math.Pow(numero, 2);

■ Arreglos Unidimensionales en Pascal

Sintaxis para la declaración de Arreglos Unidimensionales en Pascal.

■ Estructura
nombre_Arreglo : array [tamaño] of tipo;


■ Ejemplos en Pascal

• Enteros
     miArreglo : array[1..5] of integer;

• Decimales
     miArreglo : array[1..5] of real;

• Cadenas de texto
     miArreglo : array [1..5] of string;

El tamaño representa el número de 'espacios' que contendrá el arreglo, en el caso de los tipos entero o real, cada espacio puede albergar un número de tantos dígitos según el tipo, en el caso del tipo string el arreglo guardará cadenas de texto en cada uno de sus espacios.

*De la misma forma se declaran los arreglos para otros tipos como char, longint, etc.

■ Gráficamente el arreglo puede representarse así:

De enteros

De texto

■ Estructuras anidadas en Java

¿Qué son y cómo funcionan las estructuras anidadas?, lo puedes leer aquí.

Ejemplos en Java

■ if dentro de if

if (a > b) {
     if (a == 5) {
          // Instrucciones
     }
}


■ if dentro de for

for (int x = 1; x < 100; x++) {
     if (x % 2 == 0) {
          // Instrucciones
     }
}


■ if-else dentro de while

while (b > x) {
     if (b > 9) {
          // Instrucciones
     } else {
          // Instrucciones
     }
}

■ for dentro de for

for (int i=0; i<5; i++) {

    for (int j=0; j<3; j++) {

        // Instrucciones

    }

}

■ Uso práctico

Para recorrer una matriz necesitamos un doble for, el primero para recorrer sus filas y el segundo sus columnas.

Teniendo una matriz 5x3 de números como la siguente, la recorreríamos así:

int[][] Numeros = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}};

for (int i=0; i < Numeros.length; i++) {

    for (int j=0; j < Numeros[i].length; j++) {

        System.out.println(Numeros[i][j]);

    }

}

Donde:

"Numeros.length" se refiere a las filas del arreglo.

"Numeros[i].length" se refiere a las columnas de cada fila representada por "i".

■ Ejemplo de Estructuras Anidadas

■ Estructuras Anidadas

El hecho de 'anidar' estructuras se refiere a colocar unas dentro de otras según se requiera, anidar estructuras o sentencias es unas práctica muy común en la programación ya que en algunas ocasiones es forzosamente necesaria y en otras ayuda a reducir y optimizar al mismo tiempo nuestro código.

► Ejemplo:
Para a <- 1 hasta 10 hacer
     Si a < 6 entonces
          Escribe "a es menor que 6"
     Si_No
          Escribe "a es mayor o igual que 6

En el ejemplo anterior se anidaron dos estructuras: un "si" (if) dentro de un "para" (for), por lo que la sentencia "si" se ejecutará tantas veces como se repita el "para".

Para que quede un poco más claro pensemos en otro ejemplo; supongamos que necesitamos leer las calificaciones finales de un grupo de 5 alumnos, del cual debemos contar y mostrar cuantos de ellos aprobaron y cuantos no lo hicieron.

Lo haremos de dos maneras, una sin recurrir a las estructuras anidadas y la segunda anidando las estructuras necesarias.

► 1) Sin anidar

Empieza
calif[5] tipo arreglo de reales
aprobados, reprobados tipo entero

Para i <-1 hasta 5 hacer
     Escribe "Ingresa calificación"
     Leer calif[i]
Fin_Para

Si calif[1] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1

Si calif[2] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1

Si calif[3] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1

Si calif[4] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1

Si calif[5] > 5.9 entonces
     aprobados <- aprobados + 1
Si_No
     reprobados <- reprobados + 1
Fin


► 2) Empleando Estructuras Anidadas

Empieza
     calif tipo real
     aprobados, reprobados tipo entero
     Para i <- 1 hasta 5 hacer
          Escribe "Ingresa calificación "
          Leer calif
          Si calif > 5.9 entonces
               aprobados <- aprobados + 1
          Si_No
               reprobados <- reprobados + 1
          Fin_Si
     Fin_Para
     Escribe "Número de aprobados: ",aprobados
     Escribe "Número de no aprobados: ",reprobados
Fin

► Conclusión

Como puede observarse, el primer ejemplo requiere más líneas de código que el segundo (aún cuando ambos hacen lo mismo) puesto que las estructuras no están anidadas, es decir, en el primer ejemplo se piden las calificaciones en un ciclo pero se evalúan una por una fuera del mismo.

La ventaja de anidar estructuras radica en el hecho de que podemos pedir y evaluar las calificaciones en el mismo ciclo con solo colocar nuestra sentencia "si" dentro del mismo ciclo "para" como se observa en el segundo ejemplo.

Pseudocódigo 10 ► Convertir kilómetros a millas

■ Ejercicio 10: Convertir una cantidad dada en kilómetros a millas

Variables
      km, milla, millas tipo real
Empieza
      milla <- 0.621371192
      Escribe "Ingresa cantidad en km"
      Leer km
      millas <- km * milla
      Escribe km, " kilómetros equivalen a ",millas, " millas"
Fin


■ En PSeInt:

Proceso Ej_10
  milla <- 0.621371192;
  Escribir "Ingresa kilómetros"
  Leer km
  millas <- km * milla;
  Escribir  km, " kilómetros equivalen a ", millas, " millas";
FinProceso


■ Diagrama de flujo