update 0707.设计链表 python代码，java注释

problems/0707.设计链表.md

@@ -305,7 +305,7 @@ class MyLinkedList {
         head = new ListNode(0);
     }
 
-    //获取第index个节点的数值
+    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
     public int get(int index) {
         //如果index非法，返回-1
         if (index < 0 || index >= size) {
@@ -319,12 +319,12 @@ class MyLinkedList {
         return currentNode.val;
     }
 
-    //在链表最前面插入一个节点
+    //在链表最前面插入一个节点，等价于在第0个元素前添加
     public void addAtHead(int val) {
         addAtIndex(0, val);
     }
 
-    //在链表的最后插入一个节点
+    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
     public void addAtTail(int val) {
         addAtIndex(size, val);
     }
@@ -481,76 +481,90 @@ class MyLinkedList {
 Python：
 ```python
 # 单链表
-class Node:
-    
-    def __init__(self, val):
-        self.val = val
+class Node(object):
+    def __init__(self, x=0):
+        self.val = x
         self.next = None
 
-
-class MyLinkedList:
+class MyLinkedList(object):
 
     def __init__(self):
-        self._head = Node(0)  # 虚拟头部节点
-        self._count = 0  # 添加的节点数
+        self.head = Node()
+        self.size = 0 # 设置一个链表长度的属性，便于后续操作，注意每次增和删的时候都要更新
 
-    def get(self, index: int) -> int:
+    def get(self, index):
         """
-        Get the value of the index-th node in the linked list. If the index is invalid, return -1.
+        :type index: int
+        :rtype: int
         """
-        if 0 <= index < self._count:
-            node = self._head
-            for _ in range(index + 1):
-                node = node.next
-            return node.val
-        else:
+        if index < 0 or index >= self.size:
             return -1
+        cur = self.head.next
+        while(index):
+            cur = cur.next
+            index -= 1
+        return cur.val
 
-    def addAtHead(self, val: int) -> None:
+    def addAtHead(self, val):
         """
-        Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
+        :type val: int
+        :rtype: None
         """
-        self.addAtIndex(0, val)
+        new_node = Node(val)
+        new_node.next = self.head.next
+        self.head.next = new_node
+        self.size += 1
 
-    def addAtTail(self, val: int) -> None:
+    def addAtTail(self, val):
         """
-        Append a node of value val to the last element of the linked list.
+        :type val: int
+        :rtype: None
         """
-        self.addAtIndex(self._count, val)
+        new_node = Node(val)
+        cur = self.head
+        while(cur.next):
+            cur = cur.next
+        cur.next = new_node
+        self.size += 1
 
-    def addAtIndex(self, index: int, val: int) -> None:
+    def addAtIndex(self, index, val):
         """
-        Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
+        :type index: int
+        :type val: int
+        :rtype: None
         """
         if index < 0:
-            index = 0
-        elif index > self._count:
+            self.addAtHead(val)
+            return
+        elif index == self.size:
+            self.addAtTail(val)
+            return
+        elif index > self.size:
             return
 
-        # 计数累加
-        self._count += 1
-
-        add_node = Node(val)
-        prev_node, current_node = None, self._head
-        for _ in range(index + 1):
-            prev_node, current_node = current_node, current_node.next
-        else:
-            prev_node.next, add_node.next = add_node, current_node
-
-    def deleteAtIndex(self, index: int) -> None:
+        node = Node(val)
+        pre = self.head
+        while(index):
+            pre = pre.next
+            index -= 1
+        node.next = pre.next
+        pre.next = node
+        self.size += 1
+        
+    def deleteAtIndex(self, index):
         """
-        Delete the index-th node in the linked list, if the index is valid.
+        :type index: int
+        :rtype: None
         """
-        if 0 <= index < self._count:
-            # 计数-1
-            self._count -= 1
-            prev_node, current_node = None, self._head
-            for _ in range(index + 1):
-                prev_node, current_node = current_node, current_node.next
-            else:
-                prev_node.next, current_node.next = current_node.next, None
-
-
+        if index < 0 or index >= self.size:
+            return
+        pre = self.head
+        while(index):
+            pre = pre.next
+            index -= 1
+        pre.next = pre.next.next
+        self.size -= 1
+	
 # 双链表
 # 相对于单链表, Node新增了prev属性
 class Node: