Maximum Twin Sum of a Linked List - Practice Coding Problems

Maximum Twin Sum of a Linked List - Problem

In a linked list of even length n, imagine pairing up nodes like dance partners! The ith node (0-indexed) pairs with the (n-1-i)th node, creating beautiful symmetrical pairs called twins.

For example, in a linked list with 4 nodes:

Node 0 twins with Node 3
Node 1 twins with Node 2

The twin sum is simply the sum of a node's value and its twin's value. Your mission is to find the maximum twin sum among all possible twin pairs in the linked list.

Goal: Given the head of a linked list with even length, return the maximum twin sum.

Input & Output

example_1.py — Basic Case

$ Input: head = [5,4,2,1]

› Output: 6

💡 Note: The linked list has 4 nodes. Twin pairs are: (node 0, node 3) = (5,1) with sum 6, and (node 1, node 2) = (4,2) with sum 6. Maximum twin sum is 6.

example_2.py — Larger Values

$ Input: head = [4,2,2,3]

› Output: 7

💡 Note: Twin pairs are: (node 0, node 3) = (4,3) with sum 7, and (node 1, node 2) = (2,2) with sum 4. Maximum twin sum is 7.

example_3.py — Minimum Case

$ Input: head = [1,100000]

› Output: 100001

💡 Note: With only 2 nodes, there's one twin pair: (node 0, node 1) = (1,100000) with sum 100001.

Constraints

The number of nodes in the list is in the range [2, 10⁵]
The number of nodes is even
1 ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Line Up Dancers

All dancers stand in a single file line, each with their skill level

Form Twin Pairs

First dancer pairs with last, second with second-to-last, creating symmetrical pairs

Calculate Harmony

Each pair's harmony score is the sum of both dancers' skill levels

Find Best Pair

The pair with the highest harmony score wins the competition

Key Takeaway

🎯 Key Insight: The symmetrical pairing pattern (i with n-1-i) allows us to use data structures like stacks or arrays to efficiently match twins and find the maximum harmony score in linear time!

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses a stack-based approach to store the first half of the linked list values. As we traverse the second half, we pop from the stack to form twin pairs and calculate their sums in O(n) time. Alternative approaches include converting to an array for easy index access or using the reverse second half technique for O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Approach (Optimal)	O(n)	O(n)	Use stack to store first half, then pop and pair with second half in one pass
Array Storage (Two Pass)	O(n)	O(n)	Store all values in array first, then calculate twin sums using indices
Brute Force (Multiple Traversals)	O(n²)	O(1)	For each node, traverse the list to find its twin and calculate twin sum

Stack-Based Approach (Optimal) — Algorithm Steps

Traverse the linked list once to find its length
Traverse again, pushing the first n/2 values onto a stack
Continue traversing the remaining nodes, popping from stack to form twin pairs
Calculate twin sum for each pair and track the maximum
Return the maximum twin sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Push First Half

Traverse first half and push values onto stack

Pop and Pair

Traverse second half, popping stack to form twin pairs

Track Maximum

Calculate twin sums and maintain maximum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

int pairSum(struct ListNode* head) {
    // Find the length of linked list
    int length = 0;
    struct ListNode* curr = head;
    while (curr) {
        length++;
        curr = curr->next;
    }
    
    // Use array as stack to store first half
    int stack[50000]; // Assuming max constraint
    int stackTop = -1;
    curr = head;
    
    // Push first half values to stack
    for (int i = 0; i < length / 2; i++) {
        stack[++stackTop] = curr->val;
        curr = curr->next;
    }
    
    // Pop from stack and pair with second half
    int maxSum = 0;
    while (curr) {
        int firstHalfVal = stack[stackTop--];
        int twinSum = firstHalfVal + curr->val;
        if (twinSum > maxSum) {
            maxSum = twinSum;
        }
        curr = curr->next;
    }
    
    return maxSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal to find length O(n) + single traversal for calculation O(n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

Stack space to store n/2 values from the first half

⚡ Linearithmic Space

58.9K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Stack-Based Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler