Hypothetically, reverse could have been O(1). There (again hypothetically) could have been a boolean list member indicating whether the direction of the linked list is currently the same or opposite as the original one where the list was created. Unfortunately, that would reduce the performance of basically any other operation (albeit without changing the asymptotic … Read more
Let me try to clarify the cycle detection algorithm that is provided at Wikipedia – Tortoise_and_hare in my own words. How it works Let’s have a tortoise and a hare (name of the pointers) pointing to the beginning of the list with a cycle, as in the diagram above. Let’s hypothesize that if we move … Read more
Another good reason is that linked lists lend themselves nicely to efficient multi-threaded implementations. The reason for this is that changes tend to be local – affecting only a pointer or two for insert and remove at a localized part of the data structure. So, you can have many threads working on the same linked … Read more
Linked structures are possibly the worst structure to iterate with a cache miss on each element. On top of it they consume way more memory. If you need add/remove of the both ends, ArrayDeque is significantly better than a linked list. Random access each element is also O(1) for a cyclic queue. The only better … Read more
Linked lists are preferable over arrays when: you need constant-time insertions/deletions from the list (such as in real-time computing where time predictability is absolutely critical) you don’t know how many items will be in the list. With arrays, you may need to re-declare and copy memory if the array grows too big you don’t need … Read more
The C code is pretty simple, actually. Expanding one macro and pruning some irrelevant comments, the basic structure is in listobject.h, which defines a list as: typedef struct { PyObject_HEAD Py_ssize_t ob_size; /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */ PyObject **ob_item; /* ob_item contains space for ‘allocated’ elements. The number … Read more
In most cases, List<T> is more useful. LinkedList<T> will have less cost when adding/removing items in the middle of the list, whereas List<T> can only cheaply add/remove at the end of the list. LinkedList<T> is only at it’s most efficient if you are accessing sequential data (either forwards or backwards) – random access is relatively … Read more
You can make use of Floyd’s cycle-finding algorithm, also known as tortoise and hare algorithm. The idea is to have two references to the list and move them at different speeds. Move one forward by 1 node and the other by 2 nodes. If the linked list has a loop they will definitely meet. Else … Read more
Summary ArrayList with ArrayDeque are preferable in many more use-cases than LinkedList. If you’re not sure — just start with ArrayList. TLDR, in ArrayList accessing an element takes constant time [O(1)] and adding an element takes O(n) time [worst case]. In LinkedList inserting an element takes O(n) time and accessing also takes O(n) time but LinkedList … Read more