Question

I’m new to algorithm analysis and SML and got hung up on the average-case runtime of the following SML function. I would appreciate some feedback on my thinking.

fun app([]) = []
  | app(h::t) = [h] @ app(t)

So after every recursion we will end up with a bunch of single element lists (and one no-element list).

[1]@[2]@[3]@...@[n]@[]

Where n is the number of elements in the original list and 1, 2, 3, ..., n is just to illustrate what elements in the original list we are talking about. L @ R takes time linear in the length of list L. Assuming A is the constant amount of time @ takes for every element, I imagine this as if:

[1,2]@[3]@[4]@...@[n]@[] took 1A
[1,2,3]@[4]@...@[n]@[]   took 2A
[1,2,3,4]@...@[n]@[]     took 3A
...
[1,2,3,4,...,n]@[]       took (n-1)A
[1,2,3,4,...,n]          took nA

I’m therefore thinking that a recurrence for the time would look something like this:

T(0) = C                 (if n = 0)
T(n) = T(n-1) + An + B   (if n > 0)

Where C is just the final matching of the base case app([]) and B is the constant for h::t. Close the recurrence and we will get this (proof omitted):

T(n) = (n²+n)A/2 + Bn + C = (A/2)n² + (A/2)n + Bn + C = Θ(n²)

This is my own conclusion which differs from the answer that was presented to me, namely:

T(0) = B                 (if n = 0)
T(n) = T(n-1) + A        (if n > 0)

Closed form

T(n) = An + B = Θ(n)

Which is quite different. (Θ(n) vs Θ(n²)!) But isn’t this assuming that L @ R takes constant time rather than linear? For example, it would be true for addition

fun add([]) = 0
  | add(h::t) = h + add(t) (* n + ... + 2 + 1 + 0 *)

or even concatenation

fun con([]) = []
  | con(h::t) = h::con(t)  (* n :: ... :: 2 :: 1 :: [] *)

Am I misunderstanding the way that L @ R exists or is my analysis (at least sort of) correct?

Answer 1

Yes. Running the app [1,2,3] command by hand one function call at a time gives:

app [1,2,3]
[1]@(app [2,3])
[1]@([2]@(app [3]))
[1]@([2]@([3]@(app [])))
[1]@([2]@([3]@([])))
[1]@([2]@[3])
[1]@([2,3])
[1,2,3]

This is a consequence of the function call being on the left-side of the @.

Compare this to a naïve version of rev:

fun rev [] = []
  | rev (x::xs) = rev xs @ [x]

This one has the running time you expect: Once the recursion has fully expanded into an expression ((([])@[3])@[2])@[1] (taking linear time), it requires n + (n – 1) + (n – 2) + … + 1, or n(n+1)/2, or O(n^2) steps to complete the computation. A more effective rev could look like this:

local
  fun rev' [] ys = ys
    | rev' (x::xs) ys = rev' xs (x::ys)
in
  fun rev xs = rev' xs []
end