CLRS Solutions

Exercise 1.1-1

Tue, 30 Jun 2026 14:00:20 +0000

Give a real-world example that requires sorting or a real-world example that requires computing a convex hull.

Sorting : Sorting listed products in an online marketplace by price or listing blog posts alphabetically or by date
Finding Convex Hull : Finding shortest path between two points with some solid obstacles between them like solving a game maze or self-driving cars more examples

Exercise 1.1-2

Tue, 30 Jun 2026 14:00:20 +0000

Other than speed, what other measures of efficiency might one use in a real-world setting?

Memory

This is probably the most obvious one other than speed. Not only we want to utilize available memory efficiently, we might want to reduce number of memory accesses, avoid leaking memories etc.

One example is learning based approaches often needs to work with very large amount of data. If the dataset is larger than available system RAM, we will have to design our algorithm to be able to run out of core.

Power Consumption

This is particularly relevant when we are developing our algorithm for portable devices like smartphones or smartwatches etc. In such sometimes we want to settle for relatively less power hungry algorithm algorithm that does the job good enough instead of going with more power consuming complex algorithms that produce better results.

One example is anything to do with GPUs. Usually personal computers have GPUs that can consume 75-300 watts, whereas smartphone GPUs have a typical power budget of merely 1 Watt.

Exercise 1.1-3

Tue, 30 Jun 2026 14:00:20 +0000

Select a data structure that you have seen previously, and discuss its strengths and limitations.

Strengths of Linked List

Simpler addition and removal of elements, \(O(1)\) time complexity
Does not need contiguous memory space
New element can be easily inserted in any location

Limitations of Linked List

Accessing an element by index or by value means traversing the list, \(O(n)\) time complexity
Additional memory is required for storing the address (pointer) of the next/previous element.

Strengths of Array

Accessing any element by index is simple, \(O(1)\) time complexity
No additional memory required to store address

Limitations of Array

Addition or removal of elements from any index but the last means re-arranging the whole list, \(O(n)\) time complexity
Accessing an element by value means traversing the list, \(O(n)\) time complexity
Needs contiguous memory

Exercise 1.1-4

Tue, 30 Jun 2026 14:00:20 +0000

How are the shortest-path and travelling-salesman problems given above similar? How are they different?

They are similar in the sense that both traverses a graph and tries to find out the shortest path with minimum cost (sum of the weights).

They are different because shortest-path problem finds a path between two points such that sum of the weights is minimized. Whereas, travelling-salesman problem finds the path covering all the points (start and end point is same) such that sum of the weights is minimized. Also, shortest-path problem is P complex and travelling-salesman is NP-complete.

Exercise 1.1-5

Tue, 30 Jun 2026 14:00:20 +0000

Come up with a real-world problem in which only the best solution will do. Then come up with one in which a solution that is “approximately” the best is good enough.

Taking the example of sorting…

Best sorting algorithm is required when we need to sort a huge amount of data as soon as possible. For example, Sorting blog posts by date or items in an online store by price.

“Approximately” best sorting algorithm will work when we need to sort a small amount of data and/or without any time constraint. For example, analyzing data of a medical survey to make a conclusion after few days. Or finding out the ranking in a competition where 5 people participated.

Exercise 1.2-1

Tue, 30 Jun 2026 14:00:20 +0000

Give an example of an application that requires algorithmic content at the application level, and discuss the function of the algorithms involved.

If you think about it, such examples are everywhere these days, much more than when CLRS was first published (1990). Here are few such examples…

File Explorer

Applies sorting algorithm whenever the user wants to sort the files according to the filenames or file type or date modified.

Netflix or Any streaming app

Applies a handful of algorithms to achieve video decoding and some for recommending new content.

Any Game

Applies clipping algorithm to discard objects that are outside the viewport.

Exercise 1.2-2

Tue, 30 Jun 2026 14:00:20 +0000

Suppose we are comparing implementations of insertion sort and merge sort on the same machine. For inputs of size \(n\), insertion sort runs in \(8n^2\) steps, while merge sort runs in \(64n \lg n\) steps. For which values of \(n\) does insertion sort beat merge sort?

For insertion sort to beat merge sort for inputs of size \(n\), \(8n^2\) must be less than \(64n \lg n\).

\[\begin{alignedat}{2} & 8n^2 &&< 64n \lg n \\ \Rightarrow \, & \cancel {8n} \cdot n &&< \cancel {8n} \cdot 8\lg n \\ \Rightarrow \, & n &&< 8\lg n \\ \Rightarrow \, & n/8 &&< \lg n \\ \Rightarrow \, & 2^{n/8} &&< n \end{alignedat}\]

This is not a purely polynomial equation in \(n\). To find the required range of values of \(n\), there are a few different methods we can use…

Manually calculate the values of these expressions for different values of \(n\)
Use Newton’s Method
Plot these functions and find their intersections
Write a piece of code to found the values.

For this exercise, I’ll briefly describe all of these methods but going forward I’ll mostly use calculations that can be done with scientific calculator (to help the students visiting these pages) and python codes (to help myself).

Calculation

It is obvious that insertion sort runs at quadratic time which is definitely worse than merge sort’s linearithmic time for very large values of \(n\). We know for \(n = 1\), merge sort beats insertion sort. But for values greater than that, insertion sort beats merge sort. So, we will start checking from \(n = 2\) and go up to see for what value of \(n\) merge sort again starts to beat insertion sort.

Notice that for \(n < 8\), \(2^{n/8}\) will be a fraction. So, let’s start with \(n = 8\) and check for values of \(n\) which are powers of 2.

\[\begin{alignedat}{4} &n = 8 &&\Rightarrow 2^{8/8} &&= 2 &&< n \\ &n = 16 &&\Rightarrow 2^{16/8} &&= 4 &&< n \\ &n = 32 &&\Rightarrow 2^{32/8} &&= 16 &&< n \\ &n = 64 &&\Rightarrow 2^{64/8} &&= 256 &&> n \end{alignedat}\]

Note that we don’t need to continue anymore as we have found an approximate range of values for \(n\) where merge sort starts to beat insertion sort; somewhere between 32 and 64. Let’s do what we were doing but now we are going to try middle value of either range, repeatedly (or in other words, binary search, if you have been reading ahead).

\[\begin{alignedat}{2} &n = 48 \Rightarrow 2^{48/8} = 64 &&> n \\ &n = 40 \Rightarrow 2^{40/8} = 32 &&< n \\ &n = 44 \Rightarrow 2^{44/8} = 44.8 &&> n \\ &n = 42 \Rightarrow 2^{42/8} = 38.4 &&< n \\ &n = 43 \Rightarrow 2^{43/8} = 42.4 &&< n \end{alignedat}\]

So, at \(n = 44\), merge sort starts to beat insertion sort again. Therefore, for \(2 \le n \le 43\), insertion sort beats merge sort.

Newton’s Method

To apply Newton’s Method of approximation, we need to ballpark two values of \(n\) on either side of the actual solution and hit-and-try for the actual one following binary search principle. This is the principle we have almost followed in the previous section but the proper process involves calculus and way too time consuming for me to write about.

Graphical Plot

Another method to find the solutions is to plot the functions \(y = 2^{x/8}\) and \(y = x\) and finding points where they intersect.

Graph rendered by JSXGraph

From the above graph, we can see that the plots intersect at \(n = 1.1\) and \(n = 43.56\).

Here, \(n\) is the input size so it must be an integer. So, the values of \(n\) for which insertion beats merge sort is \(2 \le n \le 43\).

Python Code

Let’s start with \(n = 2\) and go up to see for what value of \(n\) it becomes smaller than \(2^{n/8}\).

You can run the python code in the below editor and see that for \(n = 44\) onwards the relationship reverses.

n = 2 while n > 2 ** (n / 8.0): n += 1 print("Minimum value of n for which merge sort runs faster is", n)

Exercise 1.2-3

Tue, 30 Jun 2026 14:00:20 +0000

What is the smallest value of \(n\) such that an algorithm whose running time is \(100n^2\) runs faster than an algorithm whose running time is \(2^n\) on the same machine?

For A to run faster than B, \(100n^2\) must be smaller than \(2^n\).

Calculation

Intuitively we can realize that A (quadratic time complexity) will run much faster than B (exponential time complexity) for very large values of \(n\).

Let’s start checking from \(n = 1\) and go up for values of \(n\) which are power of \(2\) to see where that happens.

\[\begin{alignedat}{4} &n = 1 &&\Rightarrow 100 \times 1^2 &&= 100 &&> 2^n \\ &n = 2 &&\Rightarrow 100 \times 2^2 &&= 400 &&> 2^n \\ &n = 4 &&\Rightarrow 100 \times 4^2 &&= 1600 &&> 2^n \\ &n = 8 &&\Rightarrow 100 \times 8^2 &&= 6400 &&> 2^n \\ &n = 16 &&\Rightarrow 100 \times 16^2 &&= 25600 &&< 2^n \end{alignedat}\]

Somewhere between 8 and 16, A starts to run faster than B. Let’s do what we were doing but now we are going to try middle value of the range, repeatedly (binary search).

\[n = 12 \Rightarrow 100 \times 12^2 = 14400 > 2^n \\ n = 14 \Rightarrow 100 \times 14^2 = 19600 > 2^n \\ n = 15 \Rightarrow 100 \times 15^2 = 22500 < 2^n\]

So, at \(n = 15\), A starts to run faster than B.

Code

Let’s start with \(n = 2\) and go up to see for what value of \(n\) merge sort again starts to beat insertion sort.

You can run the python code in the below editor and see that for \(n = 15\) onwards the relationship reverses.

n = 1 while 100 * n * n > 2 ** n: n += 1 print("Minimum value of n for which A runs faster than B is", n)

Problem 1-1

Tue, 30 Jun 2026 14:00:20 +0000

Comparison of Running Times

For each function \(f(n)\) and time \(t\) in the following table, determine the largest size \(n\) of a problem that can be solved in time \(t\), assuming that the algorithm to solve the problem takes \(f (n)\) microseconds.

In \(f(n)\) microseconds, largest size of problem that can be solved is \(n\). To find the largest size of problem that can be solved in time \(t\), we need to solve the following equation for \(n\)

\[f(n) = t \text{ in microseconds}\]

Once we calculate the largest size of problem that can be solved in \(1\) second (let’s say \(N\)), it is easy to do so for other time units. But remember, \(N\) is an integer, so you should not just multiply \(N\) with conversion factor- the answer will be off by huge amount for higher time complexities. Instead you should multiply in the beginning of the calculation.

Here are the calculations for largest size of problem that can be run in \(1\) second…

\[\begin{alignedat}{3} &\lg N &&= 10^6 &&\Rightarrow N = 2^{10^6} \\ &\sqrt N &&= 10^6 &&\Rightarrow N = 10^{12} \\ & N &&= 10^6 &&\Rightarrow N = 10^6 \\ &N \lg N &&= 10^6 &&\Rightarrow N = 62746 \\ &N^2 &&= 10^6 &&\Rightarrow N = 10^3 \\ &N^3 &&= 10^6 &&\Rightarrow N = 10^2 \\ &2^N &&= 10^6 &&\Rightarrow N = 6 \times \lg 10 = 19 \\ &N! &&= 10^6 &&\Rightarrow N = 9 \end{alignedat}\]

Among all the calculations, finding \(N\) for \(n \lg n\) and \(n!\) are not so obvious. For these two we’ll need to use calculator or a small snippet of code as shown below.

Python Code

from math import * # for n lg n n = 1 while n * log(n, 2) < 1000000: n += 1 print("Minimum value of n (n lg n) :", n - 1) # for n! n = 1 while factorial(n) < 1000000: n += 1 print("Minimum value of n (n!) :", n - 1)

Exercise 2.1-1

Tue, 30 Jun 2026 14:00:20 +0000

Using Figure 2.2 as a model, illustrate the operation of \(\textsc {Insertion-Sort}\) on the array \(A = \langle 31, 41, 59, 26, 41, 58 \rangle\).