Detailed Notes on

Introduction to Algorithms
These notes summarize the "Introduction to Algorithms"
presentation in simple, easy-to-understand language. Each slide
is covered with its key points, headings, and definitions,
organized for clarity and learning.

Slide 1: Analysis of Algorithms

 Heading: Lecture 1: Analysis of Algorithms
 Key Points:
o This is the first lecture from 2004 by Goodrich and

Tamassia.
o Focuses on understanding how algorithms work and

how to measure their performance.

Slide 2: Outline
 Heading: Outline
 Key Points:
o Topics covered in the lecture:

1. Introduction to algorithms.
 2. Comparing different algorithms.
3. Writing pseudocode (a simple way to describe
algorithms).
4. Analyzing how fast an algorithm runs (theoretical
analysis).
5. Understanding primitive operations (basic steps
in an algorithm).
6. Counting these basic steps.
7. Using asymptotic analysis to measure running
time (how time grows with input size).

Slide 3: Origin of the Word "Algorithm"

 Heading: Origin of word: Algorithm
 Key Points:
o The word "algorithm" comes from the name of a

Muslim author, Abu Ja'far Mohammad ibn Musa al-

Khowarizmi.
o He was born in the 8th century at Khwarizm (now

Kheva, Uzbekistan), a town south of river Oxus in

present Uzbekistan.
o Uzbekistan has been a Muslim country for over 1,000

years but was taken over by Russia in 1873.

 Simple Explanation: The term "algorithm" is named after
a historical figure who contributed to math and computing
ideas.
Slide 4: Algorithm; Informal Definition
Definition of an Algorithm
 Heading: Definition
 Definition:
o An algorithm is a set of step-by-step process to solve a

problem or perform a task.

o An algorithm is a clear, step-by-step process that takes

inputs (like numbers or data), does calculations, and

produces outputs (results).
 Key Points:
o It’s a sequence of steps to transform input into output.

 Simple Explanation: An algorithm is like a recipe—it tells

you exactly what to do with ingredients (input) to get a dish
(output).

Slide 5: Analysis of Algorithms

Algorithm Process
 Heading: Analysis of Algorithms
 Key Points:
 o An algorithm takes an input, processes it step-by-step,
and gives an output.
o It solves a problem in a limited amount of time.

 Diagram: Input → Algorithm → Output

 Simple Explanation: Think of an algorithm as a machine:
you put something in, it works on it, and spits out the
answer.

Slide 6: Model of Computation

 Heading: Model of Computation
 Key Points:
o A computational problem defines what input you have

and what output you want.

o We study algorithms in a general way so the results

apply to any computer, making them easier for

humans to read.
o Algorithms are written for people to understand, not

just for machines.

Simple Explanation: We analyze algorithms so their
performance doesn’t depend on the specific computer, operating
system, or programming language.

Slide 7: Model of Computation (RAM)

  Heading: Model of Computation
 Key Points:
o We use a Random Access Machine (RAM) model to

analyze algorithms.
o RAM is an imaginary computer with:

 Unlimited memory.

 Executes one instruction at a time (no parallel

tasks).
 Each instruction is a basic operation (like adding

numbers or comparing values).

o Basic operations include:

 Assigning a value to a variable.

 Basic math (addition, subtraction, multiplication,

division).
 Comparing values (e.g., is x ≤ 5?).

 Boolean operations (like AND, OR).

 Accessing an array element (e.g., A[10]).

o Each basic operation takes the same amount of time.

 Simple Explanation: The RAM model is like a super

simple computer we use to test algorithms, where every
small task takes the same time.

Slide 8: The Random Access Machine (RAM)

Model
 Heading: The Random Access Machine (RAM) Model
 Key Points:
 o RAM has:
 A CPU (the brain of the computer).

 Unlimited memory cells, each holding a number

or character.
 Memory cells are numbered, and accessing any

cell takes the same time (unit time).

 Simple Explanation: In the RAM model, memory is like a
huge numbered list, and grabbing any number from it is
super quick and takes the same time.

Slide 9: Why analyze an Algorithm?

What is an Algorithm?
 Heading: algorithm?
 Key Points:
o The meaning of an algorithm depends on:

 a) Its purpose (what it’s used for).

 b) How important it is compared to other

algorithms.
 c) How hard it is to analyze.

 d) How precise the answer needs to be.

 Simple Explanation: An algorithm’s value depends on

what it does, how it compares to others, how tricky it is to
study, and how accurate it needs to be.
Slide 10: Why analyze an Algorithm?
Algorithm Performance
 Heading: algorithm?
 Key Points:
o We want to know:

 How long an algorithm takes to run on a specific

computer.
 How much memory (space) it uses.

 Simple Explanation: We care about how fast an algorithm

is and how much computer memory it needs.

Slide 11: Comparing Algorithms

 Heading: Comparing Algorithms
 Key Points:
o When choosing between algorithms that solve the

same problem, we consider some criteria for selecting

an algorithm:
1. Is it easy to write, understand, or change?
2. How long does it take to finish?
3. How much memory it uses?
o Software engineering focuses on #1 (ease of use).

o This course focuses on #2 (time) and #3 (memory).

  Simple Explanation: We pick the best algorithm by
checking if it’s easy to use, fast, and doesn’t need too much
memory. This class is mostly about speed and memory.

Slide 12: Comparing Algorithms

Time and Space Complexity
 Heading: Comparing Algorithms
 Key Points:
o Time complexity: How long an algorithm takes to

finish.
o Space complexity: How much memory an algorithm

needs.
o This course mostly studies time complexity (speed).

o A better algorithm is one that runs faster (lower time

complexity).
 Simple Explanation: We measure how fast an algorithm is
(time) and how much memory it uses (space), but we care
more about speed in this class.

Slide 13: Running Time Analysis

 Heading: Running Time Analysis
 Key Points:
 o We measure:
 Execution time (how long the algorithm runs).

 Memory (space) used.

o Two ways to measure running time:

 Worst-case time: The longest time it takes for

any input of size n.

 Average-case time: The average time over all

inputs of size n.
o Worst-case formula:

 Let I be an input, |I| be its size, and T(I) be the

time it takes.
 Worst-case time: T_worst(n) = max T(I) for all

inputs I of size n.
 Formula: Tworst(n) = max |I|=n T(I).

 Simple Explanation: We check how long an algorithm

takes in the worst possible case (slowest) or on average,
and we use math to figure it out.

Slide 14: Running Time Analysis (Continued)

 Heading: Running Time Analysis
 Key Points:
o Average-case time:

 Calculated as a weighted sum: T_avg(n) = Σ p(I)

T(I), where p(I) is the probability of input I.

 o We usually focus on worst-case time because:
 It’s easier to calculate.

 It gives an upper limit (the slowest possible

time).
 Average-case is harder since we need to know the

probability of inputs.
 Simple Explanation: Worst-case time tells us the slowest
an algorithm can be, and it’s easier to figure out than
average time, which needs tricky probability math.

Slide 15: How to Calculate Running Time?

Input Size and Running Time
 Heading: (No specific heading, part of Running Time
Analysis)
  Key Points:
o Algorithms transform inputs into outputs (e.g., sorting

numbers: [5, 3, 1, 2] → [1, 2, 3, 5]).

o Running time usually grows as the input size (n)

increases.
o We analyze running time as a function of input size.

 Simple Explanation: The bigger the input, the longer an

algorithm takes. We study how time changes as the input
gets bigger.

Slide 16: How to Calculate Running Time?

Best, Worst, and Average Case
 Heading: Time
 Key Points:
o Running time varies even for inputs of the same size.

o Example: Finding the first prime number in an array

by scanning left to right.

o We analyze running time in three cases:

 Best case: Fastest time (e.g., prime is first in the

array).
 Worst case: Slowest time (e.g., no prime or

prime is last).
 Average case: Average time over all possible

inputs.
 Simple Explanation: An algorithm’s speed depends on the
input. We check its fastest, slowest, and average times.

Slide 17: How to Calculate Running Time?

Why Focus on Worst Case?
 Heading: How to Calculate Running Time
 Key Points:
o Best case: Not very useful (too optimistic).

o Average case: Useful but hard to calculate.

o Worst case: We usually focus on worst-case time

because:
  It’s easier to calculate.
 Easier to analyze.
 It gives an upper limit (the slowest possible
time).
 Important for critical applications like:
- Games.
- Finance.
- Robotics.
 Simple Explanation: We focus on the worst-case time
because it’s easier to study and matters for important tasks
where slow performance isn’t okay.

Slide 18: Experimental Evaluation of

Running Time
 Heading: Experimental Evaluation of Running Time
 Key Points:
o Steps to measure running time experimentally:

1. Write a program for the algorithm.

2. Run it with different input sizes and types.
3. Measure actual time (e.g., using
System.currentTimeMillis()).
4. Plot the results (e.g., time vs. input size).
o Example: A graph shows running time increasing with

input size.
  Simple Explanation: To test an algorithm, code it, run it
with different inputs, measure how long it takes, and make
a graph to see the pattern.

Slide 19: Limitations of Experiments

 Heading: Limitations of Experiments
 Key Points:
o Experiments are useful but have issues:

 Results may not apply to inputs not tested.

 To compare algorithms, you need the same

computer and software setup.

 Simple Explanation: Testing an algorithm is great, but the
results might not work for all cases, and you need the same
setup to compare algorithms fairly.

Slide 20: Theoretical Analysis of Running

Time
 Heading: Theoretical Analysis of Running Time
 Key Points:
o Uses pseudocode (not real code) to describe the

algorithm.
o Measures running time as a function of input size (n).
 o Considers all possible inputs.
o Independent of hardware/software (works for any

computer).
 Simple Explanation: Instead of testing, we use a fake code
description to calculate how long an algorithm takes for
any input, no matter the computer.

Slide 21: Pseudocode

 Heading: Pseudocode
 Key Points:
o Pseudocode: A simple, high-level way to describe an

algorithm.
 More structured than plain English.

 Less detailed than real code.

 Hides complex programming details.

o Example: Finding the maximum element in an array:

o Algorithm arrayMax(A, n)
o Input: array A of n integers
o Output: maximum element of A
o currentMax ← A[0]
o for i ← 1 to n-1 do
o if A[i] > currentMax then
o currentMax ← A[i]
o return currentMax
 Simple Explanation: Pseudocode is like writing a recipe
for an algorithm—clear and simple, not actual code, but
easy to understand.
Slide 22: Pseudocode Details
 Heading: Pseudocode Details
 Key Points:
o Control flow (how the algorithm flows):
 if...then...[else...]
 while...do...
 repeat...until...
 for...do...
o Use indentation instead of braces {}.
o Method declaration:

 Example: Algorithm method(arg, arg...) Input... Output...

o Repeats the arrayMax example from Slide 21.

 Simple Explanation: Pseudocode uses simple words and

indentation to show steps, like loops or conditions, without
worrying about real code syntax.

Slide 23: Counting Primitive Operations

 Heading: Operations
 Key Points:
o We count primitive operations (basic steps) in

pseudocode to estimate running time.

o Example: For arrayMax:

 currentMax ← A[0]: 2 operations.

 for i ← 1 to n-1: 2 + n operations.

 if A[i] > currentMax: 2(n-1) operations.

  currentMax ← A[i]: 2(n-1) operations.
 Increment i: 2(n-1) operations.
 return currentMax: 1 operation.
Total: 7n - 1 operations.
 Simple Explanation: We count every tiny step in the
pseudocode to figure out how much work the algorithm
does.

Slide 24: Estimating Running Time

 Heading: Estimating Running Time
 Key Points:
o For arrayMax, worst-case is 7n - 1 operations.

o Define:

 a: Time for the fastest operation.

 b: Time for the slowest operation.

o Running time T(n) is between:

 a(7n - 1) ≤ T(n) ≤ b(7n - 1).

o This means T(n) is bounded by two linear functions.

 Simple Explanation: The algorithm’s time is between a

fast and slow estimate, but it grows linearly (like a straight
line) with input size.

Slide 25: Growth Rate of Running Time

  Heading: Time
 Key Points:
o Changing the computer or software only affects T(n)

by a constant factor (e.g., doubles the time).

o It doesn’t change the growth rate (how time increases

with n).
o For arrayMax, the growth is linear (time grows

proportional to n).
o The linear growth is a core property of the algorithm.

 Simple Explanation: A better computer makes the

algorithm faster, but the way time grows with input size
stays the same—it’s linear for arrayMax.

Slide 26: Constant Factors

 Heading: Constant Factors
 Key Points:
o Growth rate ignores:

 Constant factors (e.g., multiplying by 10).

 Lower-order terms (e.g., adding 100).

o Examples:

 10²n + 10⁵ is linear (focus on n).

 10⁵n² + 10⁸n is quadratic (focus on n²).

o We simplify to focus on the main part of the running

time.
 Simple Explanation: We ignore small numbers or
constants in the time formula to focus on the big picture
(like n or n²).
Slide 27: Asymptotic Algorithm Analysis
 Heading: Analysis
 Key Points:
o Asymptotic analysis: Measures running time using

big-Oh notation (O(n)).

o Steps:

1. Find the worst-case number of primitive

operations as a function of input size.
2. Express it in big-Oh notation (ignore constants
and lower terms).
o Example: arrayMax has 7n - 1 operations → O(n) time.

o Constants and lower terms are ignored in big-Oh.

 Simple Explanation: We use big-Oh to describe how time

grows (e.g., O(n) means linear) by ignoring small details
and focusing on the worst case.

Slide 28: Important Functions

 Heading: Important Functions
 Key Points:
o Common growth rates in algorithms:

 Constant: 1 (same time always)

 Logarithmic: log n (grows slowly)
  Linear: n (grows steadily)
 N-log-N: n log n (a bit faster than
quadratic)
 Quadratic: n² (grows fast)
 Cubic: n³ (grows very fast)
 Exponential: 2ⁿ (grows extremely fast)
 Simple Explanation: Algorithms have different speed
patterns—some are super fast (constant), others are slow
(exponential).

Slide 29: Important Functions Growth Rates

Table
 Heading: Rates
 Key Points:
o Table showing how functions grow with n:

n log(n) n nlog(n) n² n³ 2ⁿ
8 3 8 24 64 512 256
16 4 16 64 256 4096 65,536
32 5 32 160 1024 32,768 4.3×10⁹
64 6 64 384 4096 262,144 1.8×10¹⁹
128 7 128 896 16,384 2,097,152 3.4×10³⁸
256 8 256 2048 65,536 16,777,218 1.2×10⁷⁷
o Shows how fast each function grows as n increases.
 Simple Explanation: This table shows that exponential
(2ⁿ) grows crazy fast, while logarithmic (log n) grows super
slow as input size gets bigger.