Question

I am trying to understand the time complexity for these two functions. I have tried experimenting with both and here is what I have come up with

List.foldBack (@) [[1];[2];[3];[4]] [] => [1] @ List.foldBack (@) [[2];[3];[4]] []
=> [1] @ ([2] @ List.foldBack (@) [[3];[4]] [])
=> [1] @ ([2] @ ([3] @ List.foldBack (@) [4] []))
=> [1] @ ([2]@([3] @ ([4] @ List.foldBack[])))
=> [1]@([2]@([3]@([4]@([])))
=> [1; 2; 3; 4]


List.fold (@) [] [[1];[2];[3];[4]]
=> List.fold (@) (([],[1])@ [2]) [[3];[4]]
=> List.fold (@)  ((([]@[1])@[2])@[3]) [[4]]
=> List.fold (@)  (((([]@[1])@[2])@[3])@[4]) []
=> (((([]@[1])@[2])@[3])@[4])

Now it seems to me that they are both linear since it takes the same amount of calculations to achieve the same result. Am i correct or is there something that I am missing?

Answer 1

If each inner operation is Θ(1), List.fold and List.foldBack is O(n) where n is the length of the list.

However, to estimate asymptotic time complexity, you need to rely on Θ(1) operations. In your example, things are a little more subtle.

Suppose you need to concatenate n lists where each list has m elements. Since @ is O(n) of the length of the left operand, we have complexity of foldBack:

  m + ... + m // n occurences of m
= O(m*n)

and that of fold:

  0 + m + 2*m + ... + (n-1)*m // each time length of left operand increases by m
= m*n*(n-1)/2
= O(m*n^2)

Therefore, with your naive way of using @, foldBack is linear while foldis quadratic to the size of input lists.

It is worth to note that @ is associative (a @ (b @ c) = (a @ b) @ c); therefore, results are the same for fold and foldBack in this case.

In practice, if the inner operator is non-associative, we need to choose the right order by either using fold or foldBack. And List.foldBack in F# is made tail-recursive by transforming lists to arrays; there are some overheads by this operation as well.