Maximum Twin Sum of a Linked List

Introduction

In this blog post, we will discuss the problem of finding the maximum twin sum of a linked list. Given a linked list of even length, we need to find the maximum sum of a node and its twin node.

Problem Statement

We are given a linked list of size n, where n is even. Each node in the linked list has a value. The ith node (0-indexed) is considered the twin of the (n-1-i)th node. Our task is to find the maximum sum of a node and its twin node in the linked list.

Data Structure Used

We will be using a singly linked list data structure to represent the given linked list. Each node in the linked list will contain a value and a pointer to the next node.

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

Algorithmic Approach

To find the maximum twin sum, we will iterate through the linked list and keep track of the maximum sum encountered so far. We will start with two pointers, one pointing to the head of the linked list and the other pointing to the twin node.

We will iterate until either of the pointers reaches the middle of the linked list. In each iteration, we will calculate the sum of the current node and its twin node and update the maximum sum if necessary. We will then move both pointers to their respective next nodes.

Finally, we will return the maximum sum obtained during the traversal.

Traverse the linked list and store the values of each node in a vector.
Initialize two pointers, i and j, to the start and end of the vector, respectively.
Initialize a variable maximumSum to 0 to keep track of the maximum sum encountered.
Iterate until i is less than j.
- Calculate the sum of values[i] and values[j].
- Update maximumSum if the calculated sum is greater than the current maximum sum.
- Increment i and decrement j.
Return maximumSum.

Implementation

int pairSum(ListNode *head)
{
    ListNode *current = head;
    vector<int> values;

    while (current)
    {
        values.push_back(current->val);
        current = current->next;
    }

    int i = 0, j = values.size() - 1;
    int maximumSum = 0;
    while (i < j)
    {
        maximumSum = max(maximumSum, values[i] + values[j]);
        i++;
        j--;
    }

    return maximumSum;
}

Time Complexity

The time complexity of this approach is O(n), where n is the length of the linked list. We need to iterate through the entire linked list to calculate the maximum twin sum.

Space Complexity

The space complexity of this approach is O(1) since we only need a constant amount of extra space to store the two pointers and temporary variables.

Conclusion

In this blog post, we discussed the problem of finding the maximum twin sum of a linked list. We presented an algorithmic approach using two pointers to iterate through the linked list and calculate the maximum sum. We analyzed the time and space complexity of the approach. This solution allows us to efficiently find the maximum twin sum in the given linked list.

Stackable