java列表处理时间

Question

This is from wikipedia: http://en.wikipedia.org/wiki/Arraylist under Performance .

ArrayList: constant time for remove(), add() at end of array, linear time to add(), remove() at beginning.

LinkedList: both of operations stated : constant time, indexing: linear.

---

1)Why the difference in arraylist processing time between the two operations?

2)Linkedlist is linear for indexing, constant for adding at the end, why?

Answer 1

1) Because to add/remove at the beginning it has to shift everything and reindex.

2) Because it maintains references to the head and tail (beginning & end). Indexing means traversing the list.

Answer 2

i) ArrayList -> You've got to push all the elements by one position in case of removal/addition in the beginning, hence linear time. At the end of array, you simply add or remove.

ii)LinkedList -> You have references of head and tail, hence you can add/remove anything there (in constant time).

Answer 3

1. Because removing at the end does not require moving the data. Adding may require copying to resize the storage array, but it's time is amortized .
2. Because adding at the end does not require walking the list, but indexing does.

Answer 4

When you add to the end of an ArrayList , it will grow itself to have some room to spare. So if you have a ten-element ArrayList , adding at the end will cause it to internally allocate room for twenty elements, copy the ten you already had, and then add one. Then, when you add another element at the end, it just sticks that twelfth element into the space it already created.

This does not technically give it constant time insertion at the end, but it does give it amortized constant time insertion. That is to say, over a large number of operations, the cost approaches constant time; each time it grows, it doubles, so you'll have an ever-larger number of "free" constant-time inserts before you have to grow-and-copy again.

When you insert at the beginning , it can't do this and must always copy the whole list into a new location (linear time).

Removal from the end is always constant time because you just switch the last cell from being "filled" to "free space". You never need to copy the list.

As for your second question, a LinkedList keeps a pointer to the end of the list, so add and remove there just use that pointer and are thus constant time. There are no quick pointers into the middle of the list, so accessing an arbitrary element requires a linear-time traversal from start to (potentially) finish.