Linked List

A hash map finds the node instantly and a doubly linked list reorders it instantly, so every get and put runs in constant time.

Advance a slow pointer by one and a fast pointer by two; if they meet there is a cycle, and a reset-and-walk phase finds its start.

Start with n components and subtract one for every edge that merges two different sets; what remains is the count.

A linked list is a chain of nodes where each node holds data and a pointer to the next node, connected by references rather than by sitting side by side in memory.

Start at the head, process each node, follow next, and stop when you reach null.

Walk from head to null with a counter, adding one per node; or keep a size field updated on every mutation for instant lookups.

Grow one tree by always pulling in the cheapest edge that reaches a new vertex.

Keep one candidate per list in a size-K min-heap and always take the global minimum.

Move slow by one and fast by two; if they ever meet there is a cycle, and if fast hits null there is none.

After the tortoise and hare meet inside the loop, move one pointer to the head and step both by one; their next meeting is the cycle's start.

Keep a dummy head, always attach the smaller of the two current nodes, then attach whatever remains.

Put the K heads in a min-heap, repeatedly poll the smallest and push its next.

Move fast N steps ahead, then move both until fast ends, and slow lands right before the node to delete.

Walk A-then-B and B-then-A; they meet at the intersection because both cover length A plus B.

BFS without level tracking; once you dequeue the target, the next node waiting in the queue is the successor.

BFS per level; capture the last node of each level into the result.

BFS per level; capture the first node of each level into the result.

Post-order return each subtree's height, and at every node update the best diameter as left height plus right height plus one.

Deduplicate the targets, count distinct targets per subtree in post-order, and return the deepest node whose subtree contains all of them.

At each node the longest path through it is left depth plus right depth, so compute depths once and track the maximum of that sum.

At each node track the best bending path (node value plus both children's positive gains) but return to the parent only one branch's gain plus the node.

At every node of the big tree, run a full same-tree check against the candidate; if any check passes, it is a subtree.

Do a level-order traversal and record the last node of each level, which is the rightmost one visible from the right.

At every node the left and right subtree heights must differ by at most one, checked in a single post-order pass that short-circuits on the first violation.