leetcode 1

输入数字个位在链表头，返回数字个位在链表尾部

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        res = ListNode(-1)
        p = res
        carry = 0
        while l1 or l2 or carry!= 0 :
            if not l1:
                num1 = 0
            else:
                num1 = l1.val
                l1 = l1.next
            if not l2:
                num2 = 0 
            else:
                num2 = l2.val
                l2 = l2.next             
            sums = num1 + num2 + carry
            carry = sums // 10
            curr = sums % 10 
            node = ListNode(curr)
            p.next = node
            p = p.next
        return res.next

leetcode 445

输入数字个位在末尾，返回数字个位在链表尾部

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        s1 ,s2 = [],[]
        while l1:
            s1.append(l1.val)
            l1 = l1.next
        while l2:
            s2.append(l2.val)
            l2 = l2.next
        res,carry = None,0
        
        while s1 or s2 or carry!= 0:
            num1 = 0 if not s1 else s1.pop()
            num2 = 0 if not s2 else s2.pop()
            sums = num1 + num2 + carry
            carry = sums // 10
            curr = sums % 10 
            node = ListNode(curr)
            node.next = res
            res = node
        return res

• 这里要将链表转化为列表来做。
• 另一个技巧点是s1.pop()这个用法，既取到了后面的数字，又去掉了数字
• 还有将链表穿起来时，每一次新生成的节点的next置为上次的结果

82： 删除排序链表中的重复元素

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。

返回同样按升序排列的结果链表。

这道题和他的相似题目（简单）的区别在于，只要出现重复，那么就要删除链表中所有的节点，一个都不允许留。比如：输入：head = [1,2,3,3,4,4,5]，删除后要输出：[1,2,5]。简单题目是要留下一个。

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        dummy = ListNode()
        dummy.next = head
        same = None
        p = head
        pre = dummy
        while p :
            nexxt = p.next
            if nexxt and nexxt.val == p.val or nexxt and nexxt.val==same:
                same = nexxt.val
                pre.next = nexxt.next
                p = pre
                continue
            pre = p
            p = p.next
        return dummy.next

这里我用了一个same变量来保存我删除的节点是什么值，这么做的目的在于，很可能删除这俩一样的元素之后，后面紧跟着又是一个相等值的元素，那这个时候其实这个第三个元素也是需要删除的。
之前same=nexxt.val这个地方我写的是same = p.val。一开始想的是既然两个值都一样，只要保存他们的相同值就可以了，但是如果是if条件的第二个情况满足，这个same值就不会变化了。这样就会出现一个问题，那就是如果是[1,1,1,1]这种情况，最后一个1还是会输出，那这样结果就不对了。愿意在于，这里的p是可能为dummy空节点的。