Added

Author: shichao-an

linked_list_cycle/solution.py

@@ -1,13 +1,22 @@
+"""
+Given a linked list, determine if it has a cycle in it.
+
+Follow up:
+Can you solve it without using extra space?
+"""
+
 # Definition for singly-linked list.
-# class ListNode:
+# class ListNode(object):
 #     def __init__(self, x):
 #         self.val = x
 #         self.next = None
 
-class Solution:
-    # @param head, a ListNode
-    # @return a boolean
+class Solution(object):
     def hasCycle(self, head):
+        """
+        :type head: ListNode
+        :rtype: bool
+        """
         slow = head
         fast = head
         while fast is not None and fast.next is not None:

palindrome_linked_list/solution.py

@@ -0,0 +1,19 @@
+"""
+Given a singly linked list, determine if it is a palindrome.
+
+Follow up:
+Could you do it in O(n) time and O(1) space?
+"""
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def isPalindrome(self, head):
+        """
+        :type head: ListNode
+        :rtype: bool
+        """

populating_next_right_pointers_in_each_node/solution.py

@@ -1,15 +1,54 @@
-# Definition for a  binary tree node
-# class TreeNode:
+"""
+Given a binary tree
+
+    struct TreeLinkNode {
+      TreeLinkNode *left;
+      TreeLinkNode *right;
+      TreeLinkNode *next;
+    }
+
+Populate each next pointer to point to its next right node. If there is no
+next right node, the next pointer should be set to NULL.
+
+Initially, all next pointers are set to NULL.
+
+Note:
+
+You may only use constant extra space.
+You may assume that it is a perfect binary tree (ie, all leaves are at the
+same level, and every parent has two children).
+
+For example,
+
+Given the following perfect binary tree,
+         1
+       /  \
+      2    3
+     / \  / \
+    4  5  6  7
+After calling your function, the tree should look like:
+         1 -> NULL
+       /  \
+      2 -> 3 -> NULL
+     / \  / \
+    4->5->6->7 -> NULL
+
+"""
+
+# Definition for binary tree with next pointer.
+# class TreeLinkNode(object):
 #     def __init__(self, x):
 #         self.val = x
 #         self.left = None
 #         self.right = None
 #         self.next = None
 
-class Solution:
-    # @param root, a tree node
-    # @return nothing
+class Solution(object):
     def connect(self, root):
+        """
+        :type root: TreeLinkNode
+        :rtype: nothing
+        """
         if root is not None:
             if root.left is not None:
                 root.left.next = root.right

remove_linked_list_elements/solution.py

@@ -0,0 +1,39 @@
+"""
+Remove all elements from a linked list of integers that have value val.
+
+Example
+Given: 1 --> 2 --> 6 --> 3 --> 4 --> 5 --> 6, val = 6
+Return: 1 --> 2 --> 3 --> 4 --> 5
+"""
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def removeElements(self, head, val):
+        """
+        :type head: ListNode
+        :type val: int
+        :rtype: ListNode
+        """
+        if head is None:
+            return None
+        current = head
+        last = None
+        while current is not None:
+            if current.val == val:
+                if last is not None:
+                    # Remove `current` node and `last` node is not changed
+                    last.next = current.next
+                else:
+                    # `current` is the head node
+                    # Remove the head node and `last` node is still None
+                    head = current.next
+                    last = None
+            else:
+                last = current
+            current = current.next
+        return head