Maximum Twin Sum of a Linked List - Problem

In a linked list of size n, where n is even, the i^th node (0-indexed) of the linked list is known as the twin of the (n-1-i)^th node, if 0 <= i <= (n / 2) - 1.

For example, if n = 4, then node 0 is the twin of node 3, and node 1 is the twin of node 2. These are the only nodes with twins for n = 4.

The twin sum is defined as the sum of a node and its twin.

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

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: Nodes (0,3) are twins with sum 5+1=6. Nodes (1,2) are twins with sum 4+2=6. Maximum is 6.

Example 2 — Different Values

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

› Output: 7

💡 Note: Nodes (0,3) are twins with sum 4+3=7. Nodes (1,2) are twins with sum 2+2=4. Maximum is 7.

Example 3 — Minimum Size

$ Input: head = [1,100000]

› Output: 100001

💡 Note: Only one twin pair (0,1) with sum 1+100000=100001.

Constraints

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

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12 G Google 8

The key insight is understanding that twin nodes are at mirrored positions: node i pairs with node (n-1-i). The optimal approach converts the linked list to an array for easy twin access, or uses a stack/reversal technique for space optimization. Time: O(n), Space: O(n) for array conversion or O(1) for reversal approach.

Common Approaches

✓ Array Conversion

⏱️ Time: O(n) Space: O(n)

First traverse the linked list to store all values in an array. Then iterate through the first half and calculate twin sums with corresponding elements from the second half.

Stack Approach

⏱️ Time: O(n) Space: O(n/2)

Push the first half of linked list values onto a stack. Then traverse the second half, popping from stack to get twin pairs and calculate maximum sum.

Two Pointers with Reversal

⏱️ Time: O(n) Space: O(1)

Find the middle of the linked list, reverse the second half, then use two pointers from start and reversed middle to calculate twin sums efficiently.

Array Conversion — Algorithm Steps

Step 1: Convert linked list to array
Step 2: Iterate first half, pair with second half
Step 3: Track maximum sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Array

Store linked list values in array

Find Twin Pairs

Match first half with second half

Maximum Sum

Track the largest twin sum

Code -

solution.c — C

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

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

struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

struct ListNode* arrayToLinkedList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = createNode(arr[0]);
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = createNode(arr[i]);
        current = current->next;
    }
    return head;
}

int solution(struct ListNode* head) {
    // Convert linked list to array
    int values[100000];
    int n = 0;
    struct ListNode* current = head;
    while (current) {
        values[n++] = current->val;
        current = current->next;
    }
    
    int maxSum = 0;
    
    // Find maximum twin sum
    for (int i = 0; i < n / 2; i++) {
        int twinSum = values[i] + values[n - 1 - i];
        if (twinSum > maxSum) {
            maxSum = twinSum;
        }
    }
    
    return maxSum;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing
    int arr[100000];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    struct ListNode* head = arrayToLinkedList(arr, size);
    printf("%d\n", solution(head));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build array plus single pass to find max twin sum

✓ Linear Growth

Space Complexity

O(n)

Array stores all n node values

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~15 min Avg. Time

825 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

Maximum Twin Sum of a Linked List - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Array Conversion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler