Editing Linked list (section)

===Linked lists vs. dynamic arrays===
{{List data structure comparison}}
A ''[[dynamic array]]'' is a data structure that allocates all elements contiguously in memory, and keeps a count of the current number of elements. If the space reserved for the dynamic array is exceeded, it is reallocated and (possibly) copied, which is an expensive operation.

Linked lists have several advantages over dynamic arrays. Insertion or deletion of an element at a specific point of a list, assuming that a pointer is indexed to the node (before the one to be removed, or before the insertion point) already, is a constant-time operation (otherwise without this reference it is O(n)), whereas insertion in a dynamic array at random locations will require moving half of the elements on average, and all the elements in the worst case. While one can "delete" an element from an array in constant time by somehow marking its slot as "vacant", this causes [[fragmentation (computer)|fragmentation]] that impedes the performance of iteration.

Moreover, arbitrarily many elements may be inserted into a linked list, limited only by the total memory available; while a dynamic array will eventually fill up its underlying array data structure and will have to reallocate—an expensive operation, one that may not even be possible if memory is fragmented, although the cost of reallocation can be averaged over insertions, and the cost of an insertion due to reallocation would still be [[Amortized analysis|amortized]] O(1). This helps with appending elements at the array's end, but inserting into (or removing from) middle positions still carries prohibitive costs due to data moving to maintain contiguity. An array from which many elements are removed may also have to be resized in order to avoid wasting too much space.

On the other hand, dynamic arrays (as well as fixed-size [[array data structure]]s) allow constant-time [[random access]], while linked lists allow only [[sequential access]] to elements. Singly linked lists, in fact, can be easily traversed in only one direction. This makes linked lists unsuitable for applications where it's useful to look up an element by its index quickly, such as [[heapsort]]. Sequential access on arrays and dynamic arrays is also faster than on linked lists on many machines, because they have optimal [[locality of reference]] and thus make good use of data caching.

Another disadvantage of linked lists is the extra storage needed for references, which often makes them impractical for lists of small data items such as [[character (computing)|characters]] or [[Boolean value]]s, because the storage overhead for the links may exceed by a factor of two or more the size of the data. In contrast, a dynamic array requires only the space for the data itself (and a very small amount of control data).<ref group="note">The amount of control data required for a dynamic array is usually of the form <math>K+B*n</math>, where <math>K</math> is a per-array constant, <math>B</math> is a per-dimension constant, and <math>n</math> is the number of dimensions. <math>K</math> and <math>B</math> are typically on the order of 10 bytes.</ref> It can also be slow, and with a naïve allocator, wasteful, to allocate memory separately for each new element, a problem generally solved using [[memory pool]]s.

Some hybrid solutions try to combine the advantages of the two representations. [[Unrolled linked list]]s store several elements in each list node, increasing cache performance while decreasing memory overhead for references. [[CDR coding]] does both these as well, by replacing references with the actual data referenced, which extends off the end of the referencing record.

A good example that highlights the pros and cons of using dynamic arrays vs. linked lists is by implementing a program that resolves the [[Josephus problem]]. The Josephus problem is an election method that works by having a group of people stand in a circle. Starting at a predetermined person, one may count around the circle ''n'' times. Once the ''n''th person is reached, one should remove them from the circle and have the members close the circle. The process is repeated until only one person is left. That person wins the election. This shows the strengths and weaknesses of a linked list vs. a dynamic array, because if the people are viewed as connected nodes in a circular linked list, then it shows how easily the linked list is able to delete nodes (as it only has to rearrange the links to the different nodes). However, the linked list will be poor at finding the next person to remove and will need to search through the list until it finds that person. A dynamic array, on the other hand, will be poor at deleting nodes (or elements) as it cannot remove one node without individually shifting all the elements up the list by one. However, it is exceptionally easy to find the ''n''th person in the circle by directly referencing them by their position in the array.

The [[list ranking]] problem concerns the efficient conversion of a linked list representation into an array. Although trivial for a conventional computer, solving this problem by a [[parallel algorithm]] is complicated and has been the subject of much research.

A [[self-balancing binary search tree|balanced tree]] has similar memory access patterns and space overhead to a linked list while permitting much more efficient indexing, taking O(log n) time instead of O(n) for a random access. However, insertion and deletion operations are more expensive due to the overhead of tree manipulations to maintain balance. Schemes exist for trees to automatically maintain themselves in a balanced state: [[AVL tree]]s or [[red–black tree]]s.