Leetcode Notes_#2 Add Two Numbers

Leetcode Notes_#2 Add Two Numbers

LeetCode 

Contents

• Problem
• Solution
• 相关Python知识

 

Problem

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example:

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.

Solution

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None 从后面来看，这个自定义的ListNode对象其实也属于可变对象
class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        dummyHead=ListNode(0)
        tmpNode=dummyHead
        p=l1#p,q以及tmpNode都可以看做是指针
        q=l2
        sum=0
        carry=0
        while p!=None or q!=None:
            a=p.val if p!=None else 0
            b=q.val if q!=None else 0
            sum=a+b+carry
            tmpNode.next=ListNode(sum%10)#新建一个节点，并加入到链表
            tmpNode=tmpNode.next#指针向后滑动（把tmpNode标签后移）
            carry=sum/10
            if p!=None:
                p=p.next
            if q!=None:
                q=q.next
        if(carry!=0):
            tmpNode.next=ListNode(carry)
            
        return dummyHead.next

summary:

• 如果是一个很长的链表，如何去访问？
  • 用一个临时变量p去存储临时的listnode,使用while循环去不断地“p=p.next”,搭配计数或者判断条件，就可以访问到特定的node
• Python中or和|的区别
  • or是逻辑运算符，连接两个布尔变量，逻辑或；|是位运算符，连接两个多位二进制数，做按位或
• 本题需要注意的几个地方：
  • 链表的操作，尤其是带注释的两句话，好好理解
  • 记得最后一位要考虑是否有进位
  • 考虑到两个数字是不同的位数的情况
  • 考虑遍历的时候避免遇到None

相关Python知识

Python的赋值是跟其他语言不一样的，Python没有变量一说，我之前所理解的“变量”，准确说来是一个指针，指向对象（Python下一切皆为对象),下面的几个例子是我从网上看到的 ^[1]
首先看可变对象的赋值：

>>> a = [1, 2, 3]
>>> b = a
>>> b.append(4)
>>> print a, b
[1, 2, 3, 4] [1, 2, 3, 4]

执行a = [1, 2, 3]后，a指向这个列表，执行b = a后，b也指向这个列表，两个变量指向同一块内
存，因此对b的操作也会影响a。

再看不可变对象的赋值：

>>> a = 1
>>> b = a
>>> a = 2
>>> print a,b
2 1

执行a=1后开辟了一块内存存放1，然后b也指向1，执行a=2后，因为整型不可变，所以又开辟
了一块内存存放2，现在a指向2，b还指向1。

我的理解：可变对象的指针的赋值，不会开辟新的内存单元，仅仅是增加了一个指向可变对象的指针，那么修改其中一个的内容，另一个也改变（因为本来就是指向同一块内存区域）；
但对于不可变对象，赋值之后是指向同一个内存块，但是其中一个变化并不会影响另一个，因为变化的时候就会重新开辟新的内存块，那么之后两个指针指向就不一样了

新建不可变对象的时候，都是直接新建一个内存空间

通过下面这个例子再感受一下可变和不可变对象：

>>>a = 1#a指向1
>>>b = 1#由于不可变，所以python不会重新建立一个存储1的内存空间(不会有新的id)，所以b的指向和a是一样的
>>>a is b
True
>>>a = [1,2]#a指向[1,2]
>>>b = [1,2]#b指向另一个[1,2],因为list之后会改变，所以不可以用同一个存储空间来存
>>>a is b
False
>>>a=[1,2]
>>>b=a
>>>a is b
True

对于is的解释：
is是python根据对象的id是否相同去判断是否是同一个对象（是否是一个存储空间)
要区别于比较运算符==,这个只是比较两个对象的值是否相同，也就是说，a和b是不同的存储单元，但是他们存储的可变对象是一样的，那么a==b成立，但是a is b不成立

---

1. Python对象赋值 ↩︎