链表 876. 链表的中间结点 2. 两数相加

最新推荐文章于 2025-09-14 17:31:33 发布

原创最新推荐文章于 2025-09-14 17:31:33 发布 · 147 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 同时被 2 个专栏收录

26 篇文章

订阅专栏

链表

4 篇文章

订阅专栏

本文深入解析了链表的中间结点寻找算法及两数相加的链表操作技巧，通过双指针法高效定位链表中点，利用循环遍历实现链表数值相加，是理解链表数据结构与算法设计的实用指南。

876. 链表的中间结点

给定一个带有头结点 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。

示例：

示例 1：
输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：
输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

思路1：双指针

定义两个指针和指针的位置，慢指针走一步，快指针走到慢指针的一倍

代码实现：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        pre = head
        cur = pre
        cur_pos = 0
        pre_pos = 0
        while cur.next:
            pre = pre.next
            pre_pos += 1
            while cur_pos < pre_pos * 2 and cur.next:
                cur = cur.next
                cur_pos += 1
        return pre

思路2：双指针优化

定义两个指针和指针的位置，慢指针走一步，快指针走两步
为什么使用while cur and cur.next的原因：
[1, 2, 3, 4, 5]
pre = 1, cur = 1
pre = 2, cur = 3
pre = 3, cur = 5
cur.next 为空，返回pre

[1, 2, 3, 4, 5, 6]
pre = 1, cur = 1
pre = 2, cur = 3
pre = 3, cur = 5
pre = 4, cur = None
cur 为空，返回pre，正好是第二个中间节点

代码实现：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        pre = head
        cur = pre
        while cur and cur.next:
            pre = pre.next
            cur = cur.next.next
        return pre

2. 两数相加

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

思路：

不断遍历两个链表，每次遍历都将链表a和链表b的值相加，再赋给链表a。如果有进位则记录一个进位标志。
循环的条件是链表a不为空或者链表b不为空，这样当整个循环结束时，链表就被串起来了。
注意：当循环结束时，如果进位标志为1还需要处理下边界条件。

代码实现

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        a, b = l1, l2
        # 定义主指针，指向l1，用来处理
        #   1. 循环结束时，进位标志为1
        #   2. a，b链表长度不一致
        # 的情况，最终返回l1
        p = None
        # 定义进位标志
        carry = 0

        while a or b:
        	# 将链表a，b的值相加，并加上可能的进位
            val = (a.val if a else 0) + (b.val if b else 0) + carry
            # 若val>10说明要进位，carry = 1否则为0
            carry = 1 if val>=10 else 0
            # 不论是否进位，val都取个位数的值
            val = val % 10
			# 主指针p指向a，值为val
            p, p.val = a if a else b, val
			# a，b向后移动，若到都头，循环结束
            a, b = a.next if a else None, b.next if b else None
            # 判断主指针的下一个指向，若a，b都为空，则指向空，若a,b有一个不为空，则指向不为空者
            p.next = a if a else b
		# 处理循环结束时，进位标志为1的情况
        if carry:
            p.next = ListNode(1)
        return l1