Scala/OCaml 中的 cons 运算符的复杂性是多少？

Question

What is complexity of these codes?

I have written the following code:

let rec replicate (element, reps) = 
    if reps < 0 then failwith "Negative reps"
    else if reps = 0 then []
    else element :: replicate (element, reps - 1);;

def replicate[A](element:A, reps:Int):List[A] = 
if (reps < 0) throw new Exception("Negative reps")
else if (reps == 0) Nil
else element :: replicate(element, reps-1)

I wonder especially what is complexity of cons operator (::).

Answer 1

Cons is O(1) so these codes are O(n) .

However this code is inefficient because it does not use tail recursion and therefore cannot be optimised into a loop (or at least using tail call elimination).

Something like this is better (for Scala)

def replicate[A](element: A, reps: Int): List[A] = {
  @annotation.tailrec
  def loop(rem: Int, res: List[A]): List[A] =
    if (rem <= 0) {
      res
    } else {
      loop(rem - 1, element :: res)
    }

  if (reps < 0) {
    throw new Exception("Negative reps")
  } else {
    loop(reps, Nil)
  }
}

This is optimised to a loop by Scala, and also avoids testing the error condition every iteration.

Of course in Scala it is easier just to use

List.fill(reps)(element)