diff --git a/animation-simulation/链表篇/面试题 02.05. 链表求和.md b/animation-simulation/链表篇/面试题 02.05. 链表求和.md
index af5aa66..f5e0efe 100644
--- a/animation-simulation/链表篇/面试题 02.05. 链表求和.md	
+++ b/animation-simulation/链表篇/面试题 02.05. 链表求和.md	
@@ -55,11 +55,11 @@
 
 了解了思路，但是想完全实现代码也不是特别容易，这里需要注意的三个点就是，
 
-1.我们需要根据两个链表的长度，不断对新链表添加节点
+1. 我们需要根据两个链表的长度，不断对新链表添加节点。
 
-2.需要创建一个变量用来保存进位值。
+2. 需要创建一个变量用来保存进位值。
 
-3.当跳出循环之后，需要根据进位值来判断需不需要再对链表长度加1.
+3. 当跳出循环之后，需要根据进位值来判断需不需要再对链表长度加1。
 
 这三条可以结合代码理解进行。
 
@@ -78,8 +78,8 @@ Java Code:
 ```java
 class Solution {
     public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-         //返回链表
-         ListNode nList = new ListNode(-1);
+         //待会儿要返回的链表
+         ListNode nList = new ListNode(-1);//虚拟头节点
          ListNode tempnode = nList;
          //用来保存进位值，初始化为0
          int summod = 0;
@@ -92,7 +92,7 @@ class Solution {
              int sum = l1num+l2num+summod;
              //更新进位值，例18/10=1，9/10=0
              summod = sum/10;
-             //新节点保存的值，18 % 8=2，则添加2
+             //新节点保存的值，18% 8=2，则添加2
              sum = sum%10; 
              //添加节点
              tempnode.next = new ListNode(sum);
@@ -106,10 +106,10 @@ class Solution {
              }            
          }
          //最后根据进位值判断需不需要继续添加节点
-         if (summod == 1) {
+         if (summod != 0) {
              tempnode.next = new ListNode(summod);
          }
-         return nList.next;
+         return nList.next;//去除-1节点
     }
 }
 ```
@@ -120,8 +120,8 @@ C++ Code:
 class Solution {
 public:
     ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
-         //返回链表
-         ListNode * nList = new ListNode(-1);
+         //待会儿要返回的链表
+         ListNode * nList = new ListNode(-1);//虚拟头节点
          ListNode * tempnode = nList;
          //用来保存进位值，初始化为0
          int summod = 0;
@@ -134,7 +134,7 @@ public:
              int sum = l1num + l2num + summod;
              //更新进位值，例18/10=1，9/10=0
              summod = sum / 10;
-             //新节点保存的值，18 % 8=2，则添加2
+             //新节点保存的值，1 %8=2，则添加2
              sum = sum % 10; 
              //添加节点
              tempnode->next = new ListNode(sum);
@@ -148,11 +148,85 @@ public:
              }            
          }
          //最后根据进位值判断需不需要继续添加节点
-         if (summod == 1) {
+         if (summod != 0) {
              tempnode->next = new ListNode(summod);
          }
-         return nList->next;
+         return nList->next;//去除-1节点
     }
 };
 ```
 
+JS Code:
+
+```js
+var addTwoNumbers = function(l1, l2) {
+    //待会儿要返回的链表
+    let nList = new ListNode(-1);//虚拟头节点
+    let tempnode = nList;
+    //用来保存进位值，初始化为0
+    let summod = 0;
+    while (l1 || l2) {
+        //如果l1的链表为空则l1num为0，若是不为空，则为链表的节点值
+        //判断是否为空，为空就设为0
+        let l1num = l1 === null ? 0 : l1.val;
+        let l2num = l2 === null ? 0 : l2.val;
+        //将链表的值和进位值相加，得到为返回链表的值
+        let sum = l1num + l2num + summod;
+        //更新进位值，例18/10=1，9/10=0
+        summod = ~~(sum / 10);
+        //新节点保存的值，1 %8=2，则添加2
+        sum = sum % 10;
+        //添加节点
+        tempnode.next = new ListNode(sum);
+        //移动指针
+        tempnode = tempnode.next;
+        if (l1) {
+            l1 = l1.next;
+        }
+        if (l2) {
+            l2 = l2.next;
+        }
+    }
+    //最后根据进位值判断需不需要继续添加节点
+    if (summod !== 0) {
+        tempnode.next = new ListNode(summod);
+    }
+    return nList.next;//去除-1节点
+};
+```
+
+Python Code:
+
+```py
+class Solution:
+    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
+        # 待会儿要返回的链表
+        nList = ListNode(-1)  # 虚拟头节点
+        tempnode = nList
+        # 用来保存进位值，初始化为0
+        summod = 0
+        while l1 is not None and l2 is not None:
+            # 如果l1的链表为空则l1num为0，若是不为空，则为链表的节点值
+            # 判断是否为空，为空就设为0
+            l1num = 0 if l1 is None else l1.val
+            l2num = 0 if l2 is None else l2.val
+            # 将链表的值和进位值相加，得到为返回链表的值
+            sum_ = l1num + l2num + summod
+            # 更新进位值，例18/10=1，9/10=0
+            # 新节点保存的值，1 %8=2，则添加2
+            # 注：这里使用divmod函数，对上方的代码进行了一丢丢的简化
+            summod, sum_ = divmod(sum_, 10)
+            # 添加节点
+            tempnode.next = ListNode(sum_)
+            # 移动指针
+            tempnode = tempnode.next
+            if l1 is not None:
+                l1 = l1.next
+            if l2 is not None:
+                l2 = l2.next
+        # 最后根据进位值判断需不需要继续添加节点
+        if summod != 0:
+            tempnode.next = ListNode(summod)
+        return nList.next  # 去除-1节点
+```
+