What is a Flowchart?

A flowchart is a visual diagram that represents the steps of an algorithm, process, or program logic. It uses different shapes and arrows to show how a program starts, accepts input, performs processing, makes decisions, displays output, and ends.

In programming, a flowchart helps students understand how a solution works before writing actual code. It shows the sequence of operations in a clear and visual way, making it easier to identify the logic of a program.

Flowcharts are especially useful for beginners because they help convert a problem statement into a clear structure. Instead of reading long paragraphs, students can follow the arrows and understand how the program moves from one step to another.

Easy Real-Life Example

In programming, the destination is the correct output, and the flowchart shows how to reach that output logically.

Why Do We Need Flowcharts?

Flowcharts are needed because they help students and programmers visualize program logic. A flowchart makes it easier to understand the order of steps, decisions, loops, and outputs before coding begins.

Algorithm vs Pseudocode vs Flowchart

Algorithms, pseudocode, and flowcharts are all used for program planning, but they represent logic in different ways.

Common Flowchart Symbols

Flowcharts use standard symbols to represent different types of operations. Each symbol has a specific meaning.

Basic Flowchart Structure

Most beginner flowcharts follow a simple structure: start, input, process, output, and end.

This structure is useful for simple programs such as adding two numbers, calculating average marks, finding area, calculating total price, or converting temperature.

Basic Control Structures in Flowcharts

Flowcharts commonly represent three basic programming control structures: sequence, selection, and repetition.

Example 1: Flowchart to Add Two Numbers

Problem Statement

IPO Analysis

Flowchart Steps

Text-Based Flowchart Representation

      ┌─────────┐
      │  Start  │
      └────┬────┘
           │
           ▼
   ┌───────────────┐
   │ Input number1 │
   └───────┬───────┘
           │
           ▼
   ┌───────────────┐
   │ Input number2 │
   └───────┬───────┘
           │
           ▼
   ┌─────────────────────────┐
   │ sum = number1 + number2 │
   └───────────┬─────────────┘
               │
               ▼
       ┌─────────────┐
       │ Display sum │
       └──────┬──────┘
              │
              ▼
          ┌─────┐
          │ End │
          └─────┘

Pseudocode

START
INPUT number1
INPUT number2
SET sum = number1 + number2
DISPLAY sum
END

Java Code

public class Main {
    public static void main(String[] args) {
        int number1 = 10;
        int number2 = 20;

        int sum = number1 + number2;

        System.out.println("Sum: " + sum);
    }
}

Example 2: Flowchart to Check Pass or Fail

Problem Statement

IPO Analysis

Text-Based Flowchart Representation

      ┌─────────┐
      │  Start  │
      └────┬────┘
           │
           ▼
     ┌─────────────┐
     │ Input marks │
     └──────┬──────┘
            │
            ▼
      ┌───────────────┐
      │ marks >= 35 ? │
      └──────┬────────┘
         Yes │ No
             │
     ┌───────▼───────┐      ┌──────────────┐
     │ Display Pass  │      │ Display Fail │
     └───────┬───────┘      └──────┬───────┘
             │                     │
             └──────────┬──────────┘
                        ▼
                    ┌─────┐
                    │ End │
                    └─────┘

Pseudocode

START
INPUT marks

IF marks >= 35 THEN
    DISPLAY "Pass"
ELSE
    DISPLAY "Fail"
END IF

END

Java Code

public class Main {
    public static void main(String[] args) {
        int marks = 40;

        if (marks >= 35) {
            System.out.println("Pass");
        } else {
            System.out.println("Fail");
        }
    }
}

Example 3: Flowchart to Print Numbers from 1 to 5

Problem Statement

Text-Based Flowchart Representation

      ┌─────────┐
      │  Start  │
      └────┬────┘
           │
           ▼
      ┌───────────┐
      │ i = 1     │
      └────┬──────┘
           │
           ▼
      ┌───────────┐
      │ i <= 5 ?  │
      └────┬──────┘
       Yes │ No
           │
           ▼
    ┌─────────────┐
    │ Display i   │
    └──────┬──────┘
           │
           ▼
      ┌───────────┐
      │ i = i + 1 │
      └────┬──────┘
           │
           └───────────────┐
                           ▼
                       i <= 5 ?
                           
       No path goes to:
              ┌─────┐
              │ End │
              └─────┘

Pseudocode

START
SET i = 1

WHILE i <= 5 DO
    DISPLAY i
    SET i = i + 1
END WHILE

END

Java Code

public class Main {
    public static void main(String[] args) {
        int i = 1;

        while (i <= 5) {
            System.out.println(i);
            i++;
        }
    }
}

Example 4: Flowchart to Find Largest of Three Numbers

Problem Statement

Pseudocode

START
INPUT A
INPUT B
INPUT C

SET max = A

IF B > max THEN
    SET max = B
END IF

IF C > max THEN
    SET max = C
END IF

DISPLAY max
END

Text-Based Flowchart Representation

      ┌─────────┐
      │  Start  │
      └────┬────┘
           │
           ▼
   ┌────────────────┐
   │ Input A, B, C  │
   └───────┬────────┘
           │
           ▼
      ┌─────────┐
      │ max = A │
      └────┬────┘
           │
           ▼
      ┌─────────┐
      │ B > max?│
      └────┬────┘
       Yes │ No
           │
           ▼
      ┌─────────┐
      │ max = B │
      └────┬────┘
           │
           ▼
      ┌─────────┐
      │ C > max?│
      └────┬────┘
       Yes │ No
           │
           ▼
      ┌─────────┐
      │ max = C │
      └────┬────┘
           │
           ▼
   ┌─────────────┐
   │ Display max │
   └──────┬──────┘
          │
          ▼
      ┌─────┐
      │ End │
      └─────┘

Java Code

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 25;
        int c = 15;

        int max = a;

        if (b > max) {
            max = b;
        }

        if (c > max) {
            max = c;
        }

        System.out.println("Largest Number: " + max);
    }
}

Rules for Drawing a Good Flowchart

A flowchart should be neat, logical, and easy to follow. Good flowcharts help students understand the logic quickly.

Decision Symbols in Flowcharts

A decision symbol is used when the program needs to choose between two or more paths. It is usually represented by a diamond shape.

Decision Example

Condition:
marks >= 35?

If Yes:
Display "Pass"

If No:
Display "Fail"

Decision symbols are important because many programs depend on conditions, such as checking pass/fail, even/odd, eligibility, login success, or discount availability.

Loops in Flowcharts

A loop in a flowchart shows that some steps are repeated while a condition remains true. Loops are useful for repeated tasks such as printing numbers, calculating totals, reading lists, or processing records.

Loop Logic Example

SET i = 1
WHILE i <= 5
    DISPLAY i
    SET i = i + 1
END WHILE

In a flowchart, the condition is placed inside a decision symbol. If the condition is true, the flow repeats. If the condition is false, the loop ends.

Flowchart vs Pseudocode

Both flowcharts and pseudocode are used before coding. The difference is in how they represent logic.

How Flowcharts Help Debugging

Flowcharts help debugging because they show the flow of logic visually. If a program gives wrong output, students can check the flowchart to find whether the mistake is in input, processing, decision, loop, or output.

Prerequisites Before Learning Flowcharts

Flowcharts are beginner-friendly, but students should understand basic problem-solving and programming concepts to draw them properly.

Common Beginner Mistakes

Practice Activity: Draw a Flowchart

This activity helps students practice creating a flowchart from a problem statement.

Problem Statement

IPO Analysis

Text-Based Flowchart Solution

      ┌─────────┐
      │  Start  │
      └────┬────┘
           │
           ▼
   ┌────────────────┐
   │ Input length   │
   └───────┬────────┘
           │
           ▼
   ┌────────────────┐
   │ Input width    │
   └───────┬────────┘
           │
           ▼
   ┌─────────────────────┐
   │ area = length*width │
   └─────────┬───────────┘
             │
             ▼
      ┌──────────────┐
      │ Display area │
      └──────┬───────┘
             │
             ▼
         ┌─────┐
         │ End │
         └─────┘

Pseudocode

START
INPUT length
INPUT width
SET area = length * width
DISPLAY area
END

Java Solution

public class Main {
    public static void main(String[] args) {
        int length = 10;
        int width = 5;

        int area = length * width;

        System.out.println("Area of Rectangle: " + area);
    }
}

Mini Quiz

Interview Questions on Flowchart

Quick Summary