LeetCode 每日一题笔记 日期：2026.06.14 题目：2130. 链表最大孪生和

LeetCode 每日一题笔记

0. 前言

• 日期：2026.06.14
• 题目：2130. 链表最大孪生和
• 难度：中等
• 标签：链表、双指针、链表反转

1. 题目理解

问题描述 ：

给定一个偶数长度 的链表，下标从 0 开始。

下标 i 和下标 n-1-i 的节点互为孪生节点，计算所有孪生节点值之和，返回其中的最大值。

示例：

输入：head = 5,4,2,1

输出：6

解释：(5+1)=6，(4+2)=6，最大和为 6。

2. 解题思路

核心观察

• 链表为偶数长度，前半段和后半段节点一一对应。
• 基础解法借助双端队列存取所有节点值，首尾配对求和。
• 优化方案：快慢指针找到链表中点，反转后半段链表，再同步遍历前后两段两两求和，节省额外空间。

算法步骤

1. 快慢指针遍历，定位链表中间位置；
2. 反转后半部分链表；
3. 同时遍历原前半段与反转后的后半段，计算节点和并记录最大值；
4. 返回最大和。

3. 代码实现

package lc2130;
import java.util.Deque;
import java.util.LinkedList;
public class Solution {
    public class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

    public int pairSum(ListNode head) {
        Deque<Integer> stack = new LinkedList<>();
        while (head != null) {
            stack.add(head.val);
            head = head.next;
        }
        int max = Integer.MIN_VALUE;
        while (!stack.isEmpty()) {
            int a = stack.removeFirst() + stack.removeLast();
            max = Math.max(a, max);
        }
        return max;
    }

}

4. 代码优化说明

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode() {}
*     ListNode(int val) { this.val = val; }
*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
  */
  class Solution {
  public int pairSum(ListNode head) {
  // 快慢指针查找链表中点
  ListNode slow = head;
  ListNode fast = head;
  while (fast != null && fast.next != null) {
  slow = slow.next;
  fast = fast.next.next;
  }

       // 反转后半段链表
       ListNode secondHalf = reserve(slow);

       int maxSum = 0;
       ListNode p1 = head;
       ListNode p2 = secondHalf;
       // 同步遍历两段链表，计算孪生和并更新最大值
       while (p2 != null) {
           maxSum = Math.max(maxSum, p1.val + p2.val);
           p1 = p1.next;
           p2 = p2.next;
       }

       return maxSum;
  }

  // 迭代方式反转链表
  private ListNode reserve(ListNode head) {
  ListNode pre = null;
  ListNode cur = head;
  while (cur != null) {
  ListNode next = cur.next;
  cur.next = pre;
  pre = cur;
  cur = next;
  }
  return pre;
  }
  }

5. 复杂度分析

• 双端队列版本
  时间复杂度：O(n)O(n)O(n)，两次线性遍历链表
  空间复杂度：O(n)O(n)O(n)，队列存储所有节点值
• 快慢指针+链表反转版本
  时间复杂度：O(n)O(n)O(n)，仅遍历链表常数次
  空间复杂度：O(1)O(1)O(1)，仅使用常数临时节点，原地操作

6. 总结

• 核心：利用链表中点分割 + 后半段反转，实现孪生节点配对。
• 优化点：舍弃额外容器，原地操作链表，大幅降低空间开销，同时减少多余分支判断。
• 关键技巧：快慢指针找中点、迭代反转链表是链表类题目的常用基础操作。