I have just signed up for the

Coursera Algorithm Design & Analysis course from Stanford. I have been meaning to take it up for a while but kept missing when it was running. As it happens, this time I have all but missed it, with the final assessments due already, but I have signed up and am going through the material and lectures on my own.

I am only on week one so far, but it is all good - the lecturer seems good and articulates the content well (so far the presentation and sophistication of the course is better than the Scala & FP course and the Logic courses I have previously done on Coursera).

After I completed the Functional Programming & Scala course, I wrote up some

notes on some of the techniques and problems in Groovy and thought it might be fun to write up some groovy notes from the algos course.

Week one is covers an introduction to algorithm analysis, divide and conquer (with merge sort) and some other stuff.

###
Mergesort - Analysis

Mergesort has three key steps

* Split the list in to two halves*
*Recursively sort the first half*
*Recursively sort the second hald*
*Merge the two sorted halves*

This is a well known example of the divide&conquer paradigm, the recursive sorting continues to recurse and divide the list into two halves until sorting is trivial (e.g. base case of one item in each list).

**Let's look at the merge step:**
*(pseudocode taken from the course)*
result = output [length = n]

leftList = 1st
sorted array [n/2]

rightList = 2nd
sorted array [n/2]

i = 1
j = 1

for k = 1 to n

if leftList(i) < rightList(j)
result(k) = leftList(i)

i++
else [rightList(j) < leftList(i)]
result(k) = rightList(j)

j++

end
The above should be fairly straight forward to understand:

**result** stores our final merged list, and will be length n (number of elements in starting array)
**leftList/rightList** - these are the two inputs to the merge, and are simple the two halves of the list that need to be merged. This assumes that both lists are already sorted prior to merging
**i/j** - These are pointers to what we consider the "head" of each list. Rather than removing items from lists we will simply keep track of a pointer for each list to track how many items of each list have been merged
- We then iterate through all "n" items, comparing the "head" of our two lists, the smaller value getting added to our result list

**Complexity analysis of merge step**:

In the course, the lecturer states that the worst case running time =

4n + 2 which he then further simplifies to =

6n (this simplification is simply because n must always be at least 1, so

4n + 2 will always be no worse than 6n.

Let's look at how we get to that figure (we will then later look at what the asymptotic run time is). This figure is simply the number of operations that need to be executed when this algorithm is run so let's count those:

result = output [length = n]

leftList = 1st
sorted array [n/2]

rightList = 2nd
sorted array [n/2]

i = 1
j = 1
In the above, the only operations that are actually set are i & j (the others are just describing the function input/output). So that costs us 2 (constant regardless of how big "n" is)

for k = 1 to n

if leftList(i) < rightList(j)
result(k) = leftList(i)

i++
else [rightList(j) < leftList(i)]
result(k) = rightList(j)

j++

end
In the above, we have one condition checking/incrementing "k" in the for statement (executed every iteration, so this will be done "n" times); we then have an IF conditional check, this will also be done in every iteration (so this is another "n" operations); then depending on which branch of that condition is executed, there are always a further two operations executed (the assignment of the head to result and the increment of the head pointer) - another two operations executed "n" times.

So the above block executes 4 operations for each of the "n" iterations. The first block executes 2 operations =

4n + 2
Seems straight forward enough. Really though, this is just a fairly simplified piece of pseudo code, and there is a bunch of additional code that is needed to handle other stuff, edge cases etc (e.g. what happens if you have added all of the left list to the result and only have the right list left? obviously that can just be appended to the results, but the above code doesn't handle this). Then there are further questions about different language implementations that might have more operations to do this (not to mention difference when it gets compiled down to machine code) - we will get more into this later when we talk about asymptotic performance. For the time being we will just say the run time (worst case) for merging two lists is

4n + 2.

**Now, let's look at recursively sorting..**
This part of the algorithm is also relatively simple, we just keep recursing through the list, splitting the list in to two halves until each half of the list is just one element (one element is already sorted!), then we can merge those lists easily.

So, if we are recursing through and splitting the list into two halves, how many times will we have to perform the merge?

Let's step through this, with an example input list of 8 elements (n=8)

- One list of 8 elements
- Two lists of 4 elements
- Four lists of 2 elements
- Eight lists of 1 elements

this is just a basic binary tree - see the illustration below taken from wikipedia:

As you can see in the above tree, it splits down into individual elements, then it re-combines them using the merge technique. To work out the complexity of the algorithm we need to know two things:

- How deep is our tree going to be?
- What is the runtime of a given depth in the tree (e.g. for a given depth "j" in the tree, what is the cost of re-merging all the lists at that level

The first question is relatively easy, as it is a binary tree we know the depth is simply going to be log

2(n)+1 -

**How do we know that**? the log of a number is simply how many times it needs to be divided by 2 (assuming 2 is the logarithm base) before the number is <= 1 - which is exactly what we are doing when we are recursively dividing our lists in half until we reach the single element lists.

E.g. the log

2(8) = 3 (8/2=4; 4/2=2; 2/2=1)

So now lets calculate the running time for any given level of the tree. Lets consider a list of length "n" and we want to know a few things:

**How many merge operations do we need to perform for depth "j" of a list "n"?**
In a similar way to how we calculated the depth, we can work out the number of merges (or number of leaves at the level of the tree). If you have halved the lists each step 0..j then the number of leaves will be 2 to the power j.

E.g. The first level down, after just halving the original list, we have j=1, so expect 2 power 1 = 2 leaves.

Second level down, we again halve each of those two lists, we have j=2, so expect 2 power 2 = 4 leaves

*Note that j cannot exceed the depth of the tree, which we already know.*
**What is the complexity of each of these merge operations?**
We know the complexity of a merge from our earlier analysis of the merge step as 6m (where m is the size of the halved lists - not the original value "n" of the starting list size), and we know we have 2 to the power j of these merges, which means we know at any level of the tree, the run time performance is:

(2 power j) * (6m)
Now the value of "m" will also be dependent on the value of "j" - because as we get further down the tree, we have a greater number of merges to perform, but the size of the lists are also getting smaller (so the actual value of "m" is decreasing), so what is the value of 6m when we are at level "j" of the tree? We can work that out in a similar fashion - we know the original "n" (size of starting list) has been halved "j" times - so it is simply

(n)/(2 power j)
So now we can combine those and resolve the algebra.. we can see that the 2 power j cancels each other out (intuitively really, as we are increasing the number of merges, but at the same time and at the same rate reducing the size of the lists to be merged:

~~(2 power j) *~~ 6 * (n~~/(2 power j)~~) = **6n**
**What is the overall complexity of the tree?**
So we now already know the complexity of any given level of the tree (independent of the depth) and we know the depth of the tree (number of levels):

6n * (log2(n)+1) =

**6nlog2(n) + 6n**
So there we have it - we have calculated the worst case running time for the merge sort.

There are a few further things that we will need to consider in later posts: In one post I will have a quick look at asymptotic analysis (e.g. "Big-Oh" notation) and what this means; in another post I will look at a Groovy implementation of it and the analysis of that.