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

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

思路：

1. 不断遍历两个链表，每次遍历都将链表a和链表b的值相加，再赋给链表a。如果有进位则记录一个进位标志。
2. 循环的条件是链表a不为空或者链表b不为空，这样当整个循环结束时，链表就被串起来了。
3. 注意：当循环结束时，如果进位标志为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