#2130 - Maximum Twin Sum of a Linked List

MediumLinked List

In a linked list of even length n, node i is the twin of node n - 1 - i. The twin sum is the sum of a node and its twin. Return the maximum twin sum of the linked list.

Input	Output
head = [5,4,2,1]	6
head = [4,2,2,3]	7
head = [1,100000]	100001

Solution Space

Try it

/**
 * Returns the maximum twin sum of a linked list with even length.
 * Twins: node i pairs with node (n - 1 - i).
 *
 * @param head Head of a linked list with even number of nodes
 * @returns    Maximum twin sum
 */
export function pairSum(head: ListNode | null): number {
  // Step 1: find the middle using slow/fast pointers
  let slow = head!;
  let fast = head!;
  while (fast && fast.next) {
    slow = slow.next!;
    fast = fast.next.next!;
  }

  // Step 2: reverse the second half starting at slow
  let prev: ListNode | null = null;
  let curr: ListNode | null = slow;
  while (curr) {
    const next = curr.next;
    curr.next = prev;
    prev = curr;
    curr = next;
  }

  // Step 3: pair nodes from front and reversed back, track max sum
  let max = 0;
  let front = head;
  let back = prev;
  while (back) {
    const sum = front!.val + back.val;
    if (sum > max) max = sum;
    front = front!.next;
    back = back.next;
  }

  return max;
}

Approach: slow/fast to find middle → reverse second half → walk both halves in tandem, tracking the maximum pair sum.

Time: O(n) – three sequential passes (find middle, reverse, pair sums).

Space: O(1) – reversal is in-place; only pointer variables used.

Alternative approaches:

Approach	Idea	Time	Space
Stack/array	Store values of the first half in an array, then pair with second half	O(n)	O(n)

Why the reverse method is preferred: O(1) space vs O(n), which matters for large lists. The stack approach is simpler to code if space is not a concern.

#2095 Delete the Middle Node of a Linked List

#104 Maximum Depth of Binary Tree