Algorithm

Lecture: Introduction to Algorithms

What is an Algorithm?

• Definition: An algorithm is a step-by-step set of instructions to solve a problem or perform

a task.
• Example: A recipe to bake a cake, or instructions to solve a math problem.

Key Properties of Algorithms

1. Input: Zero or more inputs are externally supplied.

2. Output: At least one output is produced.
3. Definiteness: Each step is precisely defined.
4. Finiteness: The algorithm must end after a finite number of steps.
5. Effectiveness: Each step must be basic enough to be carried out.

Simple Example

Problem: Add two numbers.

Algorithm:
1. Start
2. Read number A
3. Read number B
4. Add A and B, store in SUM
5. Print SUM
6. End

Types of Algorithms

1. Brute Force – Try all possible solutions

2. Greedy – Make the best choice at each step
3. Divide and Conquer – Divide the problem, solve parts, combine
4. Dynamic Programming – Store results of subproblems to avoid re-computation
5. Backtracking – Try partial solutions and backtrack if needed
6. Recursive Algorithms – Call the function within itself
 Flowchart
The first design of flowchart goes back to 1945 which was designed by John Von Neumann.
Unlike an algorithm, Flowchart uses different symbols to design a solution to a problem. It is
another commonly used programming tool.
In general, a flowchart is a diagram that uses different symbols to visually present the flow of data.
By looking at a flow chart one can understand the operations and sequence of operations performed
in a system. This is why flowchart is often considered as a blueprint of a design used for solving a
specific problem.
A flowchart is defined as a symbolic or a graphical representation of an algorithm that uses
different standard symbols.
Flowchart Symbols:

Guidelines for drawing a flowchart.

1. The Title for every flowchart is compulsory.
2. There must be START and END point for every flowchart.
3. The symbols used in flowchart should have only one entry point on the top. The exit point
for symbols (except for decision/diamond symbol) is on the button.
4. There should be two exit points for decision symbol; exit points can be on the bottom and
one side or on the sides.
5. The flow of flowchart is generally from top to bottom. But in some cases, it can also flow
to upward direction
6. The direction of the flow of control should be indicated by arrowheads.
7. The operations for every step should be written inside the symbol.
8. The language used in flowchart should be simple so that it can be easily understood.
 9. The flowlines that show the direction of flow of flowchart must not cross each other.
10. While connecting different pages of the same flowchart, Connectors must be used.

Some examples of algorithm and flowchart.

Example1: To calculate the area of a circle
Algorithm:
Step1: Start
Step2: Input radius of the circle say r
Step3: Use the formula πr2 and store result in a variable AREA
Step4: Print AREA
Step5: Stop

Flowchart:
Example 2: Design an algorithm and flowchart to input fifty numbers and calculate their
sum.
Algorithm:
Step1: Start

Step2: Initialize the count variable to zero

Step3: Initialize the sum variable to zero

Step4: Read a number say x

Step 5: Add 1 to the number in the count variable

Step6: Add the number x to the sum variable.

Step7: Is the count variable in the memory greater than 50?

If yes, display the sum: go to step 8.

If No, Repeat from step 4

Step8: Stop

Flowchart
 Algorithm vs Flowchart

Feature Algorithm Flowchart

A step-by-step textual procedure to A graphical diagram representing

Definition
solve a problem the steps of an algorithm

Written in plain language or Drawn using standard symbols and

Format
pseudocode arrows

Purpose To describe the logic clearly To visualize the logic and flow

Ease of Easier for computers/programmers to Easier for humans to understand

Understanding interpret visually

For presenting logic, training, or

Use Case For planning code or logic
debugging

Flowchart software (e.g.,

Example Tools Paper, text editor, IDE
Lucidchart, draw.io, Visio)

Why Flowcharts Are Important

1. Simplifies Understanding

• Visual representation is easier to grasp than lines of code or text.

• Ideal for beginners learning logic or programming.

2. Improves Communication

• Helps teams, clients, or non-programmers understand system logic.

• Reduces misunderstandings by using standardized symbols.

3. Aids in Problem-Solving

• Helps break down complex problems into clear, manageable steps.

• Makes it easier to identify logical errors or inefficiencies.

4. Helps in Debugging

• You can trace the flow to find where a problem occurs.

• Easier to spot missing steps or incorrect logic.

5. Supports Planning Before Coding

• Used in the design phase of software development.

• Saves time and effort by planning the logic first.

6. Useful in Teaching and Learning

• Excellent tool for explaining:

o Conditional logic (if/else)
o Loops (while, for)
o Input/output flow
o Recursion
7. Documentation Tool

• Serves as a visual document of how a system or algorithm works.

• Useful for onboarding new team members or for future updates.

Real-World Examples

Area How Flowcharts Help

Software Development Visualize app logic before coding

Business Processes Map customer support or order workflows

Education Teach algorithmic thinking and programming

Engineering Design control systems, automation logic

Data Analysis Show ETL (Extract, Transform, Load) workflows

Summary: Benefits of Flowcharts

✔ Easy to understand
✔ Visualizes logic clearly
✔ Reduces errors
✔ Aids in debugging and documentation
✔ Improves collaboration and communication
 Pseudocode: A Beginner’s Guide

What is Pseudocode?

Pseudocode is a plain-language, code-like description of an algorithm. It’s not written in any

specific programming language — it simply outlines what the program should do, step by step, in
a format that’s easy to read and translate into real code.
Think of it as the bridge between your logic and actual code.

Why Use Pseudocode?

• Helps plan your program before coding

• Focuses on logic, not syntax
• Makes it easier to communicate ideas
• Useful for beginners to understand algorithms
• Helps avoid bugs by thinking through steps first

Basic Rules of Pseudocode

There’s no strict standard, but here are common conventions:

• Use capital letters for keywords: IF, THEN, ELSE, WHILE, FOR, END
• Use indentation to show structure
• Use simple English to describe operations
• Don’t worry about exact syntax or data types

Common Pseudocode Keywords

Keyword Purpose

START / END Marks the beginning and end of the algorithm

INPUT Read data from the user

OUTPUT Display data to the user

IF, THEN, ELSE Conditional logic

FOR, WHILE Loops

SET, ← Assign value to a variable

CALL Run a subroutine or function

 Examples of Pseudocode

1. Find the Sum of Two Numbers

START
INPUT A
INPUT B
SET SUM ← A + B
OUTPUT SUM
END

2. Check if a Number is Even or Odd

START
INPUT number
IF number % 2 = 0 THEN
OUTPUT "Even"
ELSE
OUTPUT "Odd"
END IF
END

3. Find the Largest of Three Numbers

START
INPUT A, B, C
IF A > B AND A > C THEN
OUTPUT A
ELSE IF B > C THEN
OUTPUT B
ELSE
OUTPUT C
END IF
END

4. Loop Example – Print Numbers 1 to 5

START
FOR i ← 1 TO 5 DO
OUTPUT i
END FOR
END

5. Factorial of a Number (Using Loop)

START
INPUT N
SET FACT ← 1
FOR i ← 1 TO N DO
SET FACT ← FACT * i
END FOR
OUTPUT FACT
END

Pseudocode vs Flowchart

Aspect Pseudocode Flowchart

Text or Visual Text Visual

Best For Logical design before coding Teaching, presentations

Complex Logic Easier to express in detail Harder to visualize complex logic

Looks Like Code? Yes, closer to programming No

Editable Quickly? Yes Not as easily

When to Use Which?

Situation Use Pseudocode Use Flowchart

Explaining to programmers

Teaching beginners

Planning code structure

Showing a quick overview of logic

Documenting system design

 Lecture: Complexity of Algorithms

1. What is Algorithmic Complexity?

Algorithmic complexity refers to the resources an algorithm consumes, typically:

• Time: How long the algorithm takes to run
• Space: How much memory (RAM) it uses
This helps you:
• Compare different algorithms
• Choose the most efficient one for large inputs
• Understand how your code will scale

2. Time Complexity

What is Time Complexity?

It describes how the runtime of an algorithm increases with the size of the input, usually
represented by n.
We use Big O notation to describe the upper bound (worst-case) behavior.

Common Time Complexities

Complexity Name Example Algorithm Description

O(1) Constant Accessing array element Same time regardless of input size

O(log n) Logarithmic Binary Search Halves the problem at each step

O(n) Linear Linear Search Time grows directly with input size

O(n log n) Linearithmic Merge Sort, Quick Sort Efficient sorting

O(n²) Quadratic Bubble Sort Nested loops over the input

O(2ⁿ) Exponential Recursive Fibonacci Time doubles with each additional input

O(n!) Factorial Solving permutations Extremely slow growth

Examples

O(1) – Constant Time

def get_first_element(arr):
return arr[0]
→ Always one step, regardless of array size.
 O(n) – Linear Time

def find_max(arr):
max_val = arr[0]
for val in arr:
if val > max_val:
max_val = val
return max_val
→ Must check each item once → grows with n.

O(n²) – Quadratic Time

def bubble_sort(arr):
for I in range(len(arr)):
for j in range(len(arr) – I – 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
→ Each item compared with each other → n × n.

How to Analyze Time Complexity

1. Count the number of basic operations (e.g., additions, comparisons).

2. Focus on the most dominant term (ignore constants and low-order terms).
o For 3n + 2, complexity is O(n)
o For 5n² + 4n + 7, complexity is O(n²)

3. Space Complexity

What is Space Complexity?

It measures how much additional memory an algorithm needs as the input size increases.

Example

def sum_array(arr):
total = 0
for num in arr:
total += num
return total
→ Uses constant space: one variable (total) → O(1)
 When Space Matters

• Recursion: Each recursive call adds to the call stack

• Storing auxiliary structures: Hash tables, lists, matrices
• Dynamic Programming: Memoization uses extra space
Example – Fibonacci with memoization (O(n) space)
def fib(n):
memo = [0, 1]
for i in range(2, n+1):
memo.append(memo[i-1] + memo[i-2])
return memo[n]

4. Best, Worst, and Average Case

• Best Case: Minimum time (e.g., searching and finding on the first try)
• Worst Case: Maximum time (used for Big O)
• Average Case: Expected time for random inputs
Binary Search Example:

Case Time Complexity

Best O(1)

Worst O(log n)

Average O(log n)

5. Tradeoffs

Sometimes:
• Faster time needs more space (and vice versa)
• Choosing between algorithm efficiency and implementation simplicity

Algorithm Time Complexity Space Complexity

Merge Sort O(n log n) O(n)

Quick Sort O(n log n) O(log n)

Bubble Sort O(n²) O(1)

Dynamic Fib O(n) O(n)

Recursive Fib O(2ⁿ) O(n)