TikTok·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

TikTok SWE interview with a linked list problem that looks manageable until you actually sit down to implement it. The group-reversal logic with the edge case on the final group is where things get tricky.

Questions Asked (1)

Given the head of a singly linked list, traverse it in contiguous groups of increasing size (1, 2, 3, ...). For each group, reverse it if its actual node count is even, and leave it alone if odd. The last group may be shorter than expected, so use its real length to decide. Return the modified list head.

Algorithms & Data Structures

Author's notes

I spent way too long second-guessing the final group edge case.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Use a dummy node to simplify edge cases, then iterate through the list in groups of increasing size. For each group, determine its actual length, and if even, reverse it in place; otherwise, leave it unchanged. Carefully link the previous group's tail to the current group's head after processing.

Pro tip: Emphasize the importance of handling the last group correctly by checking its actual length before deciding to reverse, and discuss how the dummy node technique simplifies pointer manipulation and edge cases.

1. Initialize pointers and dummy node

Create a dummy node pointing to the head to simplify edge cases. Maintain a pointer to the last node of the previously processed group (prev_tail) and a pointer to the current node (curr).

2. Iterate with increasing group size

Use a variable group_size starting at 1. For each group, traverse group_size nodes from curr to find the group's end and count the actual number of nodes (actual_len).

3. Decide and reverse if needed

If actual_len is even, reverse the group by adjusting pointers; otherwise, leave it as is. Ensure the reversed group's tail connects to the next node.

4. Link groups and update pointers

Connect the previous group's tail to the current group's head (after reversal if applied). Update prev_tail to the last node of the current group and move curr to the next node.

5. Continue until end of list

Increment group_size and repeat steps 2-4 until curr becomes null. Return dummy.next as the new head.

Key Points to Mention

Use of dummy node to handle edge cases like empty list or reversal of the first group.
Tracking previous group's tail to maintain proper links between groups.
Determining actual group length, especially for the last group, before deciding to reverse.
In-place reversal of a sublist with careful pointer updates to avoid losing nodes.
Time complexity O(n) and space complexity O(1).
Handling of edge cases: empty list, single node, groups of size 1 (always odd, no reversal).

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.