Scala数组尾部函数的性能

Question

Scala docs says that the performance of tail for an Array sequence is Linear while head performance is Constant . Since the whole block that contains array elements is brought to cache, I don't expect to see any difference between head and tail for an array. I appreciate if someone explains why tail performance for arrays in Scala is linear.

Answer 1

The tail function creates a new array containing all of the elements except the first. To do this we need to create a copy of the array (minus the first element), which is a linear time operation. As the array gets larger there is more to copy.

Use List instead if you require efficient head and tail operations.

You may be confusing tail with last

• head gets the first element: O(1) for List and Array
• last gets the last element: O(n) for List, O(1) for Array
• tail gets everything except the first: O(1) for List, O(n) for Array
• init gets everything except the last: O(n) for List and Array

Answer 2

There is a pretty big difference between lists and arrays . head and tail are the canonical interface to lists, which in Scala, are singly linked lists. head refers to the first thing in the list and tail refers to all of the elements after the first. Since linked lists implement the tail as a pointer, this operation is a constant time operation.

However, things are a little different for arrays. Arrays are used for fast random access and refers to a contiguous block of memory. Scala still exposes the list-like interface of head and tail , but it has to do things a little differently to simulate that. In order to simulate tail , it has to make a new array containing all elements except the first. It has to copy all of its values into a new array, which is a linear time operation.