Diagramas de Flujo

¿Qué es un diagrama de flujo?

Un diagrama de flujo es un dibujo que representa los pasos de un algoritmo usando figuras geométricas conectadas por flechas. Es como un mapa que te muestra el camino que sigue tu programa desde el inicio hasta el final.

¿Por qué usar diagramas de flujo?

Imagina que quieres explicarle a un amigo cómo llegar a tu casa. Podrías darle instrucciones escritas: "camina dos cuadras, gira a la derecha, camina una cuadra más...". Pero sería mucho más fácil dibujarle un mapa. El diagrama de flujo es ese mapa, pero para algoritmos.

Los diagramas de flujo son útiles porque:

• Hacen visible la lógica de tu programa antes de escribir código.
• Ayudan a encontrar errores en tu razonamiento.
• Facilitan la comunicación con otras personas.
• Son el primer paso antes de programar cualquier solución.

Símbolos básicos

Cada figura geométrica tiene un significado específico. Es un lenguaje universal:

Tu primer diagrama: ¿Par o impar?

Vamos a hacer un diagrama para un programa muy simple: leer un número y decir si es par o impar.

El algoritmo en palabras:

1. Leer un número.
2. Si el número es divisible por 2, es par.
3. Si no, es impar.
4. Mostrar el resultado.

El diagrama:

    ┌─────────┐
    │ INICIO  │
    └────┬────┘
         │
    ┌────▼────┐
    │ Leer n  │
    └────┬────┘
         │
    ┌────▼────┐
    │ ¿n % 2  │
    │  == 0?  │
    └────┬────┘
      Sí │    No
    ┌────▼────┐  ┌────▼────┐
    │Mostrar  │  │Mostrar  │
    │ "Par"   │  │"Impar"  │
    └────┬────┘  └────┬────┘
         │           │
         └─────┬─────┘
         ┌─────▼─────┐
         │    FIN     │
         └───────────┘

Leamos el diagrama juntos:

1. Empezamos en INICIO.
2. Seguimos la flecha y llegamos a "Leer n" — aquí el programa pide al usuario un número.
3. Seguimos la flecha y llegamos al rombo de decisión: "¿n % 2 == 0?". Esta es una pregunta con dos respuestas posibles.
4. Si la respuesta es Sí (el número es divisible por 2), seguimos el camino izquierdo y mostramos "Par".
5. Si la respuesta es No, seguimos el camino derecho y mostramos "Impar".
6. Ambos caminos se unen y terminamos en FIN.

El código correspondiente:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;           // "Leer n" del diagrama

    if (n % 2 == 0) {   // El rombo de decisión
        cout << "Par" << endl;    // Camino del "Sí"
    } else {
        cout << "Impar" << endl;  // Camino del "No"
    }

    return 0;           // "FIN" del diagrama
}

¿Ves cómo el diagrama y el código se corresponden exactamente? Cada figura del diagrama tiene su equivalente en código.

Las tres estructuras fundamentales

Todo algoritmo, por complejo que sea, se puede construir con solo tres tipos de estructuras:

1. Secuencia: "Haz esto, luego esto, luego esto"

Las instrucciones se ejecutan una tras otra, en orden, como leer un libro página por página.

    ┌─────────┐
    │ Paso 1  │    Ejemplo: Calcular el área de un rectángulo
    └────┬────┘
         │         1. Leer base
    ┌────▼────┐
    │ Paso 2  │    2. Leer altura
    └────┬────┘
         │
    ┌────▼────┐
    │ Paso 3  │    3. area = base × altura
    └────┬────┘
         │
    ┌────▼────┐
    │ Paso 4  │    4. Mostrar area
    └─────────┘

int main() {
    double base, altura;
    cin >> base >> altura;          // Pasos 1 y 2
    double area = base * altura;    // Paso 3
    cout << area << endl;           // Paso 4
    return 0;
}

2. Selección (decisión): "Si pasa esto, haz aquello; si no, haz lo otro"

El programa llega a un punto donde debe elegir entre dos caminos, dependiendo de una condición.

         ┌──────────┐
         │¿Condición│
         │   ?      │
         └────┬─────┘
        Sí    │    No
    ┌─────────┘─────────┐
    │                   │
┌───▼───┐         ┌───▼───┐
│Camino │         │Camino │
│  A    │         │  B    │
└───┬───┘         └───┬───┘
    │                 │
    └────────┬────────┘
             ▼

Es como llegar a una bifurcación en un camino. Un letrero dice: "Si llueve, ve por la izquierda (hay techo). Si no llueve, ve por la derecha (es más corto)."

3. Repetición (ciclo): "Repite esto mientras se cumpla una condición"

El programa repite un bloque de instrucciones varias veces.

    ┌──────────────────┐
    │                  │
    │   ┌──────────┐   │
    └──►│¿Condición│   │
        │   ?      │   │
        └────┬─────┘   │
        Sí   │    No   │
        ┌────┘    │    │
        │         │    │
   ┌────▼────┐    │    │
   │ Cuerpo  │    │    │
   │del ciclo│────┘    │
   └─────────┘         │
              │         │
              └─────────┘
              No
              ▼
          (continúa)

Es como dar vueltas en una pista de carreras: sigues dando vueltas mientras no hayas completado las vueltas requeridas. Cuando las completas, sales de la pista.

Ejemplo completo: Calcular el factorial

El factorial de n (escrito n!) es multiplicar todos los números del 1 al n. Por ejemplo, 5! = 1 × 2 × 3 × 4 × 5 = 120.

Diagrama:

    ┌─────────┐
    │ INICIO  │
    └────┬────┘
         │
    ┌────▼────┐
    │ Leer n  │
    └────┬────┘
         │
    ┌────▼────────┐
    │ fact = 1    │  ← Iniciamos el resultado en 1
    │ i = 1       │  ← Iniciamos el contador en 1
    └────┬────────┘
         │
    ┌────▼─────┐
    │ ¿i <= n? │◄────────┐
    └────┬─────┘         │
      Sí │    No         │
    ┌────┘    │          │
    │         │          │
┌───▼────────┐│    ┌─────┴────┐
│fact = fact  ││    │ i = i + 1│
│    × i     ││    └─────┬────┘
└────┬───────┘│          │
     │        │          │
     └────────┼──────────┘
              │
    ┌─────────▼─────────┐
    │ Mostrar fact      │
    └─────────┬─────────┘
              │
         ┌────▼────┐
         │   FIN   │
         └─────────┘

Seguimiento del diagrama para n = 4:

Código:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    long long fact = 1;
    for (int i = 1; i <= n; i++) {
        fact = fact * i;
    }

    cout << fact << endl;
    return 0;
}

Ejemplo: Sumar números hasta que el usuario ingrese 0

Este ejemplo muestra un ciclo while donde no sabemos de antemano cuántas veces repetir.

Diagrama:

    ┌─────────┐
    │ INICIO  │
    └────┬────┘
         │
    ┌────▼────┐
    │ suma = 0│
    └────┬────┘
         │
    ┌────▼────┐
    │ Leer n  │◄────────┐
    └────┬────┘         │
         │              │
    ┌────▼─────┐        │
    │ ¿n != 0? │        │
    └────┬─────┘        │
      Sí │    No        │
    ┌────┘    │         │
    │         │         │
┌───▼────────┐│         │
│suma = suma ││         │
│    + n     │├─────────┘
└────┬───────┘│
     │   ┌────▼────┐
     │   │ Leer n  │
     │   └─────────┘
     │
    ┌▼────────────────┐
    │ Mostrar suma    │
    └────────┬────────┘
             │
        ┌────▼────┐
        │   FIN   │
        └─────────┘

Código:

#include <iostream>
using namespace std;

int main() {
    int suma = 0;
    int n;

    cin >> n;              // Leemos el primer número
    while (n != 0) {       // Mientras no sea 0...
        suma = suma + n;   // ...lo sumamos
        cin >> n;          // ...y leemos el siguiente
    }

    cout << suma << endl;  // Mostramos el resultado
    return 0;
}

Ejemplo de ejecución:

• El usuario escribe: 5, 3, 7, 0
• suma va cambiando: 0 → 5 → 8 → 15
• Al leer 0, el ciclo se detiene y se muestra: 15

Buenas prácticas al dibujar diagramas

1. Flujo de arriba a abajo: El diagrama siempre se lee de arriba hacia abajo y de izquierda a derecha.
2. Un solo inicio y un solo fin: No puede haber múltiples puntos de inicio.
3. Claridad: Cada figura debe contener instrucciones cortas y claras. "suma = suma + n" está bien; "calcular la suma acumulada del valor ingresado por el usuario hasta el momento" es demasiado largo.
4. Evitar cruces: Las flechas no deben cruzarse entre sí si es posible.
5. Nombrar las salidas de las decisiones: Siempre escribe "Sí" y "No" en las flechas que salen de un rombo.

Herramientas para crear diagramas

• Papel y lápiz — ¡La forma más rápida! Perfecta para planear antes de programar.
• Draw.io (diagrams.net) — Gratis, funciona en el navegador, muchos símbolos disponibles.
• Lucidchart — Más profesional, tiene una versión gratuita limitada.
• Excalidraw — Estilo "dibujado a mano", muy intuitivo.

Ejercicio de práctica

Dibuja el diagrama de flujo para un programa que lea un número y determine si es primo.

Recuerda: Un número primo solo es divisible entre 1 y sí mismo. Para verificarlo, intentamos dividirlo entre todos los números desde 2 hasta su raíz cuadrada.

    ┌─────────┐
    │ INICIO  │
    └────┬────┘
         │
    ┌────▼────┐
    │ Leer n  │
    └────┬────┘
         │
    ┌────▼─────┐
    │ ¿n < 2?  │
    └────┬─────┘
      Sí │    No
    ┌────┘    │
    │    ┌────▼────────┐
    │    │ i = 2       │
    │    │ primo = true │
    │    └────┬────────┘
    │         │
    │    ┌────▼──────────┐
    │    │¿i*i <= n AND  │◄──┐
    │    │  primo?       │   │
    │    └────┬──────────┘   │
    │      Sí │    No        │
    │    ┌────┘    │         │
    │    │         │         │
    │  ┌─▼──────┐  │    ┌────┴────┐
    │  │¿n%i==0?│  │    │ i = i+1 │
    │  └───┬────┘  │    └─────────┘
    │    Sí│  No   │
    │  ┌───▼────┐  │
    │  │primo = │──┘
    │  │ false  │
    │  └────────┘
    │         │
    ├─────────┘
    │
┌───▼──────────┐
│ ¿primo?      │
└───┬──────────┘
  Sí│        No
┌───▼───┐ ┌───▼───────┐
│"Es    │ │"No es     │
│primo" │ │primo"     │
└───┬───┘ └───┬───────┘
    └─────┬───┘
     ┌────▼────┐
     │   FIN   │
     └─────────┘

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    if (n < 2) {
        cout << "No es primo" << endl;
    } else {
        bool primo = true;
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                primo = false;
                break;
            }
        }

        if (primo) {
            cout << "Es primo" << endl;
        } else {
            cout << "No es primo" << endl;
        }
    }

    return 0;
}

Siguiente paso

Ahora que sabes representar algoritmos visualmente, es hora de aprender a escribir código real. Ve a Estructura de un Programa en C++ para comenzar con el lenguaje de programación.