Longest Consecutive Sequence Explained: Tracing [100, 4, 200, 1, 3, 2]

Imagine you are handed a scrambled set of numbers like our given array $nums=[100,4,200,1,3,2]$ and asked to find the length of the longest consecutive sequence where numbers follow each other in counting order, such as $1,2,3,4$. Your eyes naturally want to line them up in order, but what happens when the array grows from six elements to six million? Sorting the entire collection takes $O(N\log N)$ time, which feels unnecessarily heavy just to spot adjacent numerical neighbors hiding across distant memory addresses. Without a deliberate strategy, you end up repeatedly scanning the array or losing track of which numbers you have already counted in your runs. We need a way to spot these chains instantly without paying the full sorting tax, setting up the exact problem that the longest consecutive sequence technique solves.

Instead of sorting nums = $[100,4,200,1,3,2]$ in $O(N\log N)$ time, we can visualize the problem as building islands of consecutive integers. We first insert every element of our array into a hash set to allow $O(1)$ lookups. The core mental model relies on a selective trigger: we only start counting the length of a sequence if the number immediately preceding it ($x-1$) is absent from the set. For instance, when looking at 4, we check if 3 exists; since it does, 4 is skipped because it is an interior element, not a sequence head. But when we encounter 1, we check if 0 is in the set—it is absent, meaning 1 is the official starting post of a valid contiguous run.

Now let us trace our locked example array $\text{nums}=[100,4,200,1,3,2]$ using the set lookup model we established. We will track the exact state of our hash set and how our conditional check prevents redundant inner loops.

Now that you have traced the set lookup algorithm on the original locked example, it is time to test your mental model on a slightly different input. Consider an array that introduces negative numbers and a duplicate value: nums = [-1, 0, 1, 0, 3, 2]. Following the exact mechanics you learned—converting the array to a hash set and checking whether x - 1 exists before starting a forward count—try to determine how the algorithm evaluates this new set. Remember that duplicates like 0 will share the same set membership, meaning checking x - 1 for each will behave cleanly without extra sorting overhead.

Now that you have mastered the hash set pattern for finding the longest consecutive run in $\text{nums}=[100,4,200,1,3,2]$, you can transfer this structural thinking to a related array puzzle. Suppose you are asked to find not just the longest sequence of consecutive integers, but the maximum sum of any contiguous subsegment whose elements form a consecutive sequence. The core pattern remains identical: instead of sorting the whole dataset in $O(N\log N)$ time, we use a membership structure to locate sequence boundaries instantly, ensuring we only scan forward when we stand at a valid sequence head.