- Algorithm And Complexity - Uma Madam

1. Define O, Ω and Θ notations with the help of graph.

In the context of Algorithm and Complexity, Big O (O), Big Omega (Ω), and
Big Theta (Θ) are mathematical notations used to describe the asymptotic
behavior of algorithms in terms of their performance (time or space) relative to
input size, typically represented by n. These notations help analyze and compare
the efficiency of algorithms.
1. Big O (O) Notation:
Big O notation describes the upper bound of an algorithm's growth rate,
representing the worst-case scenario. It provides an upper limit on the running time,
ensuring that the algorithm will not exceed a certain time complexity as the input
grows.
 Definition: If a function f(n) is O(g(n)), then for large enough n, f(n) will
never grow faster than a constant multiple of g(n).
 Graph Representation: The graph of an O(n) function is always above the
graph of the actual runtime, representing the worst-case scenario.
 Example: If an algorithm runs in O(n²), this means that, at most, its running
time will increase quadratically with the input size n.
2. Big Omega (Ω) Notation:
Big Omega notation describes the lower bound of an algorithm's growth rate,
representing the best-case scenario or the minimum time required for the algorithm
to complete, regardless of input size.
 Definition: If a function f(n) is Ω(g(n)), then for large enough n, f(n) will not
grow slower than a constant multiple of g(n).
 Graph Representation: The graph of an Ω(n) function lies below the graph
of the actual runtime, indicating the minimum time the algorithm will take.
 Example: If an algorithm is Ω(n), this means that, at best, the algorithm will
take at least linear time in the best-case scenario.
3. Big Theta (Θ) Notation:
Big Theta notation describes a tight bound, meaning the function grows at the
same rate both in the upper and lower bounds. It represents the exact asymptotic
behavior of an algorithm.
 Definition: If a function f(n) is Θ(g(n)), then for large enough n, f(n) is
bounded both above and below by constant multiples of g(n). This means
f(n) and g(n) grow at the same rate asymptotically.
  Graph Representation: The graph of Θ(n) function matches the runtime
curve, both above and below, indicating that the algorithm's time complexity
is tightly bound.
 Example: If an algorithm has a complexity of Θ(n log n), it means the
algorithm will always take n log n time for large inputs, both in the worst and
best cases.
Graphical Representation:
 O(n): The line is an upper bound, typically above the actual running time.
 Ω(n): The line is a lower bound, typically below the actual running time.
 Θ(n): The line tightly bounds the actual running time, indicating that the
algorithm’s time complexity is sandwiched between the upper and lower
bounds.
Summary in Graph:
 O(g(n)): The function will not grow faster than g(n) (upper bound).
 Ω(g(n)): The function will not grow slower than g(n) (lower bound).
 Θ(g(n)): The function grows at the same rate as g(n) asymptotically (exact
bound).
These notations are essential for understanding and analyzing algorithm efficiency,
particularly as the input size grows larger.

2) Represent following function using O, © and S notations.

a) T(n)= 3n+2
b) T(n)= 10n'+2n+1
To represent the following functions using Big O (O), Big Omega (Ω), and Big
Theta (Θ) notations, we analyze the growth rates of the functions and determine
the asymptotic bounds.
a) T(n)=3n+2T(n) = 3n + 2T(n)=3n+2
1. Big O (O) Notation:
o O(n) represents the upper bound of the function. The term with the
highest growth rate is 3n3n3n, so the function grows linearly with nnn,
and we can say that: T(n)=O(n)T(n) = O(n)T(n)=O(n)
o The constant 333 and the term 222 are disregarded in Big O notation
because we focus on the highest-order term.
 2. Big Omega (Ω) Notation:
o Ω(n) represents the lower bound of the function. Since 3n+23n +
23n+2 grows linearly with nnn, and the constant term 222 does not
affect the growth rate, we have: T(n)=Ω(n)T(n) = Ω(n)T(n)=Ω(n)
3. Big Theta (Θ) Notation:
o Θ(n) represents a tight bound on the function. Since the function
grows linearly with nnn, we have: T(n)=Θ(n)T(n) = Θ(n)T(n)=Θ(n)
b) T(n)=10n2+2n+1T(n) = 10n^2 + 2n + 1T(n)=10n2+2n+1
1. Big O (O) Notation:
o The highest-order term in 10n2+2n+110n^2 + 2n + 110n2+2n+1 is
10n210n^210n2, so the function grows quadratically with nnn.
Therefore, we have: T(n)=O(n2)T(n) = O(n^2)T(n)=O(n2)
2. Big Omega (Ω) Notation:
o Since the leading term is 10n210n^210n2, the function will never grow
slower than quadratic growth, so: T(n)=Ω(n2)T(n) = Ω(n^2)T(n)=Ω(n2)
3. Big Theta (Θ) Notation:
o The function grows exactly like n2n^2n2, so the function has a tight
bound of quadratic growth. Therefore: T(n)=Θ(n2)T(n) =
Θ(n^2)T(n)=Θ(n2)
Summary:
 a) T(n)=3n+2T(n) = 3n + 2T(n)=3n+2:
o O(n)O(n)O(n), Ω(n)Ω(n)Ω(n), Θ(n)Θ(n)Θ(n)

 b) T(n)=10n2+2n+1T(n) = 10n^2 + 2n + 1T(n)=10n2+2n+1:

o O(n2)O(n^2)O(n2), Ω(n2)Ω(n^2)Ω(n2), Θ(n2)Θ(n^2)Θ(n2)

These notations indicate that both functions grow linearly and quadratically,
respectively, as nnn increases.

3) Explain three cases of Master's method.

The Master's Theorem is a powerful tool used to analyze the time complexity of
divide-and-conquer algorithms. It helps solve recurrences that have the following
general form:
T(n)=aT(nb)+f(n)T(n) = aT\left(\frac{n}{b}\right) + f(n)T(n)=aT(bn)+f(n)
Where:
  a≥1a \geq 1a≥1 is the number of subproblems.
 b>1b > 1b>1 is the factor by which the problem size is reduced.
 f(n)f(n)f(n) is the cost of dividing the problem and combining the results.
The Master's Theorem provides a way to determine the asymptotic behavior of
such recurrences by comparing the growth rates of f(n)f(n)f(n) and nlog⁡ban^{\log_b
a}nlogba (the critical exponent). There are three cases in the theorem, which
describe the solution based on the relationship between f(n)f(n)f(n) and nlog⁡ban^{\
log_b a}nlogba:

Case 1: Polynomially Smaller (f(n)f(n)f(n) is smaller than nlog⁡ban^{\log_b

a}nlogba)

If f(n)f(n)f(n) grows slower than nlog⁡ban^{\log_b a}nlogba, the solution to the

recurrence is dominated by the work done in the recursive calls. The time
complexity is:

T(n)=O(nlog⁡ba)T(n) = O(n^{\log_b a})T(n)=O(nlogba)

 Condition: f(n)=O(nd)f(n) = O(n^d)f(n)=O(nd) where d<log⁡bad < \log_b

ad<logba
 Example: T(n)=2T(n2)+nT(n) = 2T\left(\frac{n}{2}\right) + nT(n)=2T(2n)
+n, here log⁡ba=log⁡22=1\log_b a = \log_2 2 = 1logba=log22=1, and
f(n)=nf(n) = nf(n)=n. Since the cost is nnn, it’s smaller than nlog⁡ban^{\log_b
a}nlogba, so the solution is O(n)O(n)O(n).

Case 2: Polynomially Equal (f(n)f(n)f(n) is of the same order as nlog⁡ban^{\

log_b a}nlogba)

If f(n)f(n)f(n) and nlog⁡ban^{\log_b a}nlogba grow at the same rate, the time
complexity is determined by both the recursive calls and the cost of combining the
results. The solution is:

T(n)=O(nlog⁡balog⁡n)T(n) = O(n^{\log_b a} \log n)T(n)=O(nlogbalogn)

 Condition: f(n)=Θ(nlog⁡ba)f(n) = Θ(n^{\log_b a})f(n)=Θ(nlogba)

 Example: T(n)=2T(n2)+nT(n) = 2T\left(\frac{n}{2}\right) + nT(n)=2T(2n)
+n, here log⁡ba=1\log_b a = 1logba=1, and f(n)=nf(n) = nf(n)=n. Since the
cost is nnn, the solution is O(nlog⁡n)O(n \log n)O(nlogn).

Case 3: Polynomially Larger (f(n)f(n)f(n) is larger than nlog⁡ban^{\log_b

a}nlogba)

If f(n)f(n)f(n) grows faster than nlog⁡ban^{\log_b a}nlogba, the time complexity is

dominated by the cost of dividing and combining the results. The solution is:
T(n)=O(f(n))T(n) = O(f(n))T(n)=O(f(n))
  Condition: f(n)=Ω(nd)f(n) = Ω(n^d)f(n)=Ω(nd) where d>log⁡bad > \log_b
ad>logba, and af(n/b)≤cf(n)af(n/b) \leq cf(n)af(n/b)≤cf(n) for some constant
c<1c < 1c<1 and sufficiently large nnn.
 Example: T(n)=T(n2)+n2T(n) = T\left(\frac{n}{2}\right) + n^2T(n)=T(2n)
+n2, here log⁡ba=0\log_b a = 0logba=0, and f(n)=n2f(n) = n^2f(n)=n2. Since
n2n^2n2 is larger than nlog⁡ban^{\log_b a}nlogba, the solution is
O(n2)O(n^2)O(n2).
Summary of the Three Cases:

1. Case 1: If f(n)=O(nlog⁡ba−ϵ)f(n) = O(n^{\log_b a - \epsilon})f(n)=O(nlogb

a−ϵ) for some ϵ>0\epsilon > 0ϵ>0, then T(n)=O(nlog⁡ba)T(n) = O(n^{\log_b
a})T(n)=O(nlogba).

2. Case 2: If f(n)=Θ(nlog⁡ba)f(n) = Θ(n^{\log_b a})f(n)=Θ(nlogba), then

T(n)=O(nlog⁡balog⁡n)T(n) = O(n^{\log_b a} \log n)T(n)=O(nlogbalogn).

3. Case 3: If f(n)=Ω(nlog⁡ba+ϵ)f(n) = Ω(n^{\log_b a + \epsilon})f(n)=Ω(nlogb

a+ϵ) for some ϵ>0\epsilon > 0ϵ>0, and regularity condition holds, then
T(n)=O(f(n))T(n) = O(f(n))T(n)=O(f(n)).
These cases allow us to quickly determine the time complexity of divide-and-
conquer algorithms without solving the recurrence explicitly.

4) Find solution to the following recurrence relation using Master's method.

T(n)=9T(n/3)+n
o solve the recurrence T(n)=9T(n/3)+nT(n) = 9T(n/3) + nT(n)=9T(n/3)+n using the
Master's Theorem, we first compare it to the standard form of divide-and-conquer
recurrences:
T(n)=aT(n/b)+f(n)T(n) = aT(n/b) + f(n)T(n)=aT(n/b)+f(n)
Here, the parameters are:
 a=9a = 9a=9
 b=3b = 3b=3
 f(n)=nf(n) = nf(n)=n

Now, let's calculate log⁡ba\log_b alogba:

log⁡ba=log⁡39=2\log_b a = \log_3 9 = 2logba=log39=2

So, we have the following comparison between f(n)f(n)f(n) and nlog⁡ba=n2n^{\log_b

a} = n^2nlogba=n2:
 f(n)=nf(n) = nf(n)=n
  nlog⁡ba=n2n^{\log_b a} = n^2nlogba=n2
Apply Master's Theorem:

Now, we compare f(n)f(n)f(n) with nlog⁡ba=n2n^{\log_b a} = n^2nlogba=n2:

 Case 1: If f(n)=O(nd)f(n) = O(n^d)f(n)=O(nd) where d<log⁡bad < \log_b

ad<logba, the complexity is T(n)=O(nlog⁡ba)T(n) = O(n^{\log_b
a})T(n)=O(nlogba).

 Case 2: If f(n)=Θ(nlog⁡ba)f(n) = Θ(n^{\log_b a})f(n)=Θ(nlogba), the

complexity is T(n)=O(nlog⁡balog⁡n)T(n) = O(n^{\log_b a} \log n)T(n)=O(nlogb
alogn).

 Case 3: If f(n)=Ω(nd)f(n) = Ω(n^d)f(n)=Ω(nd) where d>log⁡bad > \log_b

ad>logba, and regularity condition holds, the complexity is T(n)=O(f(n))T(n)
= O(f(n))T(n)=O(f(n)).
Determine which case applies:
 In this case, f(n)=nf(n) = nf(n)=n and n2n^2n2 grows faster than nnn (i.e.,
f(n)=O(n2−ϵ)f(n) = O(n^{2 - \epsilon})f(n)=O(n2−ϵ) for some ϵ>0\epsilon >
0ϵ>0).
 This corresponds to Case 1 because f(n)=O(nd)f(n) = O(n^{d})f(n)=O(nd)
with d=1d = 1d=1, and 1<21 < 21<2.
Conclusion:
Since this fits Case 1, the solution to the recurrence is:

T(n)=O(nlog⁡ba)=O(n2)T(n) = O(n^{\log_b a}) = O(n^2)T(n)=O(nlogba)=O(n2)

Thus, the time complexity of the recurrence T(n)=9T(n/3)+nT(n) = 9T(n/3) +
nT(n)=9T(n/3)+n is O(n2)O(n^2)O(n2).

5) Write a short note on Matrix-chain multiplication.

Matrix-chain multiplication is an optimization problem where the goal is to
determine the most efficient way to multiply a sequence of matrices. Given a chain
of matrices, the task is to find the optimal parenthesization that minimizes the
number of scalar multiplications required. The problem can be solved using dynamic
programming by breaking it into smaller subproblems, where each subproblem
represents the minimum cost to multiply a subset of matrices. The recurrence
relation for the problem is based on splitting the chain at different points and
calculating the cost of multiplying the resulting subchains. The dynamic
programming solution has a time complexity of O(n3)O(n^3)O(n3), where nnn is the
number of matrices. This approach is widely used in applications like computer
graphics and scientific computing.
6) Explain Bellman Ford algorithm with example.
The Bellman-Ford algorithm is a classic algorithm used to find the shortest path
from a single source vertex to all other vertices in a weighted graph. It works for
graphs with negative weight edges and can detect negative weight cycles (cycles
where the total sum of edge weights is negative).
Steps of the Bellman-Ford Algorithm:
1. Initialization: Set the distance to the source vertex as 0 and all other
vertices' distances as infinity.
2. Relaxation: For each edge (u,v)(u, v)(u,v) with weight w(u,v)w(u, v)w(u,v), if
the distance to vertex vvv through vertex uuu is shorter than the current
known distance to vvv, update the distance to vvv.
3. Repeat: Perform the relaxation step for all edges, V-1 times, where VVV is
the number of vertices in the graph.
4. Negative Cycle Check: After V−1V-1V−1 relaxations, check all edges again.
If any edge can still be relaxed, it indicates the presence of a negative weight
cycle.
Time Complexity:

 The algorithm runs in O(V⋅E)O(V \cdot E)O(V⋅E), where VVV is the number of
vertices and EEE is the number of edges.
Example:
Consider the following graph with 5 vertices (A, B, C, D, E) and the edges:
 A → B (weight 6)
 A → D (weight 7)
 B → C (weight 5)
 B → D (weight 8)
 B → E (weight -4)
 C → E (weight 2)
 D → B (weight -3)
 D → E (weight 9)
 E → D (weight 7)
We want to find the shortest paths from vertex A.
1. Initialization:
o Distance from A to A = 0, all others are infinity:
Distance = {A: 0, B: ∞, C: ∞, D: ∞, E: ∞}
 2. First Relaxation (V-1 = 4 times):
o After relaxing all edges, the distance array might look like: Distance =
{A: 0, B: 6, C: 11, D: 7, E: 2}
3. Second Relaxation:
o Continue relaxing the edges, updating the shortest distances. After all
relaxations, the shortest distances would be: Distance = {A: 0, B: 6, C:
11, D: 7, E: 2}
4. Negative Cycle Check:
o If any edge can still be relaxed after V−1V-1V−1 iterations, it indicates
a negative weight cycle. In this example, no negative cycle exists.
Final Shortest Paths from A:
 A → A: 0
 A → B: 6
 A → C: 11
 A → D: 7
 A → E: 2
Thus, Bellman-Ford finds the shortest paths from A to all other vertices, even with
negative edge weights, and detects negative weight cycles if present.

7) Explain Floyd Warshall algorithm with example.

The Floyd-Warshall algorithm is a dynamic programming algorithm used to find
the shortest paths between all pairs of vertices in a weighted graph. It works on
both directed and undirected graphs and can handle graphs with negative weight
edges (but not negative weight cycles).
Steps of the Floyd-Warshall Algorithm:
1. Initialization: Create a distance matrix DDD where D[i][j]D[i][j]D[i][j] is the
direct distance from vertex iii to vertex jjj. If there's no direct edge, set D[i]
[j]D[i][j]D[i][j] to infinity.
2. Relaxation: Update the matrix by considering each vertex kkk as an
intermediate vertex. For each pair of vertices (i,j)(i, j)(i,j), update the distance
D[i][j]D[i][j]D[i][j] as the minimum of the current distance and the sum of the
distances from iii to kkk and kkk to jjj: D[i][j]=min⁡(D[i][j],D[i][k]+D[k][j])D[i][j]
= \min(D[i][j], D[i][k] + D[k][j])D[i][j]=min(D[i][j],D[i][k]+D[k][j])
 3. Repeat: Perform the above update for all vertices kkk, iterating through all
pairs of vertices iii and jjj.
Time Complexity:
 The time complexity is O(V3)O(V^3)O(V3), where VVV is the number of
vertices, since we check every pair of vertices for every intermediate vertex.
Example:
Consider the following graph with 4 vertices (A, B, C, D) and edge weights:
 A → B (5)
 A → C (10)
 B → C (3)
 C → D (1)
The initial distance matrix DDD would be:
D=[0510∞∞03∞∞∞01∞∞∞0]D = \begin{bmatrix} 0 & 5 & 10 & \infty \\ \infty & 0 &
3 & \infty \\ \infty & \infty & 0 & 1 \\ \infty & \infty & \infty & 0 \end{bmatrix}D=
0∞∞∞50∞∞1030∞∞∞10
Step-by-step:
1. Initialize the matrix with the direct distances (or infinity where there's no
direct edge).
2. Iterate for each vertex kkk as an intermediate vertex:
o For k=Ak = Ak=A: Update the matrix considering paths through
vertex A.
o For k=Bk = Bk=B: Update the matrix considering paths through
vertex B.
o For k=Ck = Ck=C: Update the matrix considering paths through
vertex C.
o For k=Dk = Dk=D: Update the matrix considering paths through
vertex D.
3. After all iterations, the matrix DDD would contain the shortest path distances
between all pairs of vertices.
Final Shortest Path Matrix:
D=[0589803471201∞∞∞0]D = \begin{bmatrix} 0 & 5 & 8 & 9 \\ 8 & 0 & 3 & 4 \\ 7
& 12 & 0 & 1 \\ \infty & \infty & \infty & 0 \end{bmatrix}D=087∞5012∞830∞9410
This matrix shows the shortest path distances between every pair of vertices:
 The shortest path from A to C is 8 (via B).
  The shortest path from B to D is 4 (via C).
 The shortest path from C to A is 7 (via B).
Conclusion:
The Floyd-Warshall algorithm efficiently finds the shortest paths between all pairs of
vertices in O(V3)O(V^3)O(V3) time, making it useful for dense graphs or when you
need the shortest paths between all pairs of vertices, even if negative weights are
involved.

8) Find time complexity of given algorithm.

A()
int i,j,k,n;
for(i=1;i<=n;i++)
for(=1;j<=ij++)
for(k=1;k<=100;k**)
printf("RAVI");

A()
int i, j, k, n;
for(i = 1; i <= n; i++) // Outer loop (1)
for(j = 1; j <= i; j++) // Middle loop (2)
for(k = 1; k <= 100; k++) // Inner loop (3)
printf("RAVI");

Analysis:
1. Outer loop (i loop):
o The outer loop runs from i=1i = 1i=1 to i=ni = ni=n, so it executes n
times.
2. Middle loop (j loop):
o The middle loop runs from j=1j = 1j=1 to j=ij = ij=i. For each value of
iii, the number of iterations of the jjj-loop is iii.
 o Therefore, the middle loop runs iii times for each iteration of iii, which
gives a total of:
Total iterations of the middle loop=∑i=1ni=n(n+1)2=O(n2)\text{Total iterations of
the middle loop} = \sum_{i=1}^{n} i = \frac{n(n + 1)}{2} =
O(n^2)Total iterations of the middle loop=i=1∑ni=2n(n+1)=O(n2)
3. Inner loop (k loop):
o The inner loop runs from k=1k = 1k=1 to k=100k = 100k=100, which
is constant and always executes 100 times for each iteration of the jjj-
loop.
Total Time Complexity:
 For each iteration of the outer loop (which runs nnn times), the middle loop
runs iii times, and the inner loop runs 100 times.
 Therefore, the total number of printf("RAVI") executions is:
Total executions of printf=∑i=1ni×100=100×n(n+1)2=O(n2)\text{Total
executions of printf} = \sum_{i=1}^{n} i \times 100 = 100 \times \
frac{n(n+1)}{2} = O(n^2)Total executions of printf=i=1∑n
i×100=100×2n(n+1)=O(n2)
Thus, the time complexity of the algorithm is O(n2)O(n^2)O(n2).

9)Explain Dijkstras algorithm with example.

Dijkstra's Algorithm is used to find the shortest path from a source node to all
other nodes in a weighted graph. It works by iteratively selecting the node with the
smallest tentative distance, exploring its neighbors, and updating their distances.
Steps of Dijkstra's Algorithm:
1. Initialization:
o Set the tentative distance for the source node as 0 and for all other
nodes as infinity.
o Mark all nodes as unvisited.

2. Visit the node:

o Start from the source node and check all of its neighbors. If a shorter
path to a neighbor is found, update the tentative distance.
3. Mark the node as visited:
 o After visiting a node and updating the distances to its neighbors, mark
it as visited so it will not be checked again.
4. Select the next unvisited node with the smallest tentative distance:
o Move to the unvisited node with the smallest tentative distance and
repeat the process until all nodes are visited.
5. Termination:
o The algorithm stops when all nodes have been visited, and the shortest
path to each node is known.
Example:
Consider the following graph:
css
Copy code
A
/ \
4 1
/ \
B ----> C
\ /
2 6
\/
D
 Vertices: A, B, C, D
 Edges with weights:
o A → B (4)

o A → C (1)

o B → C (2)

o B → D (5)

o C → D (6)

We will find the shortest path from A to all other vertices.

Step-by-step Execution:
1. Initialization:
 o Distance[A] = 0, Distance[B] = ∞, Distance[C] = ∞, Distance[D] = ∞

o Mark all nodes as unvisited.

2. Visit A:
o Neighbors of A: B and C

o Distance to B via A: 0+4=40 + 4 = 40+4=4, so Distance[B] = 4.

o Distance to C via A: 0+1=10 + 1 = 10+1=1, so Distance[C] = 1.

o Mark A as visited.

o Updated distances: Distance[A] = 0, Distance[B] = 4, Distance[C] = 1,

Distance[D] = ∞.
3. Visit C (the node with the smallest distance of 1):
o Neighbors of C: B and D

o Distance to B via C: 1+2=31 + 2 = 31+2=3, which is smaller than the

current Distance[B] = 4. So, update Distance[B] = 3.
o Distance to D via C: 1+6=71 + 6 = 71+6=7, so Distance[D] = 7.

o Mark C as visited.

o Updated distances: Distance[A] = 0, Distance[B] = 3, Distance[C] = 1,

Distance[D] = 7.
4. Visit B (the node with the smallest distance of 3):
o Neighbors of B: A, C, and D

o Distance to D via B: 3+5=83 + 5 = 83+5=8, which is larger than the

current Distance[D] = 7, so no update.
o Mark B as visited.

o Updated distances: Distance[A] = 0, Distance[B] = 3, Distance[C] = 1,

Distance[D] = 7.
5. Visit D (the node with the smallest distance of 7):
o All neighbors of D are already visited, so no updates.

o Mark D as visited.

o Final distances: Distance[A] = 0, Distance[B] = 3, Distance[C] = 1,

Distance[D] = 7.
Final Shortest Path Distances:
 A → A: 0
  A → B: 3
 A → C: 1
 A → D: 7
Conclusion:
Dijkstra’s algorithm has successfully computed the shortest path from node A to all
other nodes in the graph. The algorithm ensures optimal performance for graphs
with non-negative edge weights.

10) Generate variable length Huffman code for following set of frequencies.
a:30 b:5 c:2 d:28 e:13 f:10 g:8 h:20 1:6

To generate a variable-length Huffman code for the given set of frequencies, we

need to follow the Huffman coding algorithm. The general steps are:
1. Create a priority queue (min-heap) with all the characters and their
corresponding frequencies.
2. Iteratively combine the two least frequent nodes (characters or
subtrees) into a new internal node. The frequency of the new node is the sum
of the two nodes' frequencies.
3. Repeat the process until only one node remains. This node represents the
root of the Huffman tree.
4. Assign binary codes to each character based on the path taken from the
root to the leaf nodes (left child = 0, right child = 1).
Given frequencies:
makefile
Copy code
a: 30
b: 5
c: 2
d: 28
e: 13
f: 10
g: 8
h: 20
1: 6
Step-by-Step Process:
1. Start with the frequencies in a priority queue (min-heap):
css
Copy code
[(2, c), (5, b), (6, 1), (8, g), (10, f), (13, e), (20, h), (28, d), (30, a)]
2. Combine the two least frequent nodes:
o Combine c (2) and b (5) into a new node (7, cb). The combined
frequency is 7.
css
Copy code
[(6, 1), (7, cb), (8, g), (10, f), (13, e), (20, h), (28, d), (30, a)]
3. Combine the next two least frequent nodes:
o Combine 1 (6) and g (8) into a new node (14, 1g).

css
Copy code
[(7, cb), (10, f), (13, e), (14, 1g), (20, h), (28, d), (30, a)]
4. Combine the next two least frequent nodes:
o Combine cb (7) and f (10) into a new node (17, cbf).

css
Copy code
[(13, e), (14, 1g), (17, cbf), (20, h), (28, d), (30, a)]
5. Combine the next two least frequent nodes:
o Combine e (13) and 1g (14) into a new node (27, e1g).

css
Copy code
[(17, cbf), (20, h), (27, e1g), (28, d), (30, a)]
6. Combine the next two least frequent nodes:
o Combine cbf (17) and h (20) into a new node (37, cbfh).
css
Copy code
[(27, e1g), (28, d), (30, a), (37, cbfh)]
7. Combine the next two least frequent nodes:
o Combine e1g (27) and d (28) into a new node (55, e1gd).

css
Copy code
[(30, a), (37, cbfh), (55, e1gd)]
8. Combine the next two least frequent nodes:
o Combine a (30) and cbfh (37) into a new node (67, acbfh).

css
Copy code
[(55, e1gd), (67, acbfh)]
9. Combine the last two nodes:
o Combine e1gd (55) and acbfh (67) into the root node (122, root).

css
Copy code
[(122, root)]
Final Huffman Tree Structure:
scss
Copy code
root(122)
/ \
e1gd(55) acbfh(67)
/ \ / \
e(13) 1g(14) cbf(17) h(20)
/ \ /
cb(7) f(10) g(8)
/ \
c(2) b(5)
Huffman Codes:
 a: 0
 h: 11
 d: 101
 e: 1000
 1: 1001
 g: 11010
 f: 11011
 c: 111010
 b: 111011
Final Huffman Code for each symbol:

Symb Frequen Huffman

ol cy Code

a 30 0

b 5 111011

c 2 111010

d 28 101

e 13 1000

f 10 11011

g 8 11010

h 20 11

1 6 1001

Thus, the Huffman codes for each symbol are generated based on their frequencies,
with the most frequent symbols getting shorter codes and the less frequent ones
getting longer codes.