If you represent a list by a pointer to its first node (list) The algorithm to detect loops is described as follows: Declare two pointers (pFast) and (pSlow). Make pSlow and pFast point to list. Until (pSlow), (pFast) or both point to NULL: If , then STOP as a loop has just been found. If … Read more
Write it like this: template<typename T> LinkedList<T>::LinkedList() { start = nullptr; current = nullptr; } And similarly for other member functions. But you’ll run into another problem – declarations and definitions of a template can’t be separated to different files.
Keep in mind that what looks poor asymptotics might actually not be, because you are working in a lazy language. In a strict language, appending to the end of a linked list in this way would always be O(n). In a lazy language, it’s O(n) only if you actually traverse to the end of the … Read more
Yes, LinkedList is a doubly linked list, as the Javadoc mentions : Doubly-linked list implementation of the List and Deque interfaces. Implements all optional list operations, and permits all elements (including null). All of the operations perform as could be expected for a doubly-linked list. Operations that index into the list will traverse the list … Read more
It is certainly not possible with a plain singly-linked list. Sketch proof: to examine the last node of a singly-linked list, we must perform n-1 operations of following a “next” pointer [proof by induction on the fact that there is only one reference to the k+1th node, and it is in the kth node, and … Read more
It’s definitely more a quiz rather than a real problem. However, if we are allowed to make some assumption, it can be solved in O(1) time. To do it, the strictures the list points to must be copyable. The algorithm is as the following: We have a list looking like: … -> Node(i-1) -> Node(i) … Read more
Your requirements are exactly those of std::list, except that you’ve decided you don’t like the overhead of node-based allocation. The sane approach is to start at the top and only do as much as you really need: Just use std::list. Benchmark it: is the default allocator really too slow for your purposes? No: you’re done. … Read more
Update (in response to your comment): you’re right, discussing big-O notation by itself is not exactly useful. I included a link to James’s answer in my original response because he already offered a good explanation of the technical reasons why List<T> outperforms LinkedList<T> in general. Basically, it’s a matter of memory allocation and locality. When … Read more
For some needs, a deque may also be useful. You can add and remove items on both ends of a deque at O(1) cost. from collections import deque d = deque([1,2,3,4]) print d for x in d: print x print d.pop(), d
The two statements you’ve written each construct a LinkedList<String> object to hold a list of strings, then assign it to a variable. The difference is in the type of the variable. By assigning the LinkedList<String> to a variable of type Queue<String>, you can only access the methods in the LinkedList that are available in the … Read more