Adding solution os 142, 143, 144, 145, 147 problems

Author: Garvit244

100-200q/142.py

@@ -0,0 +1,38 @@
+'''
+	Given a linked list, return the node where the cycle begins. If there is no cycle, return null.
+
+	Note: Do not modify the linked list.
+
+	Follow up:
+	Can you solve it without using extra space?
+'''
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def detectCycle(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if not head:
+        	return None
+
+        slow, fast = head, head.next
+
+        while fast and fast.next:
+        	slow = slow.next
+        	fast = fast.next.next
+        	if slow == fast:
+        		break
+
+        if slow == fast:
+        	slow = head
+        	while slow != fast:
+        		slow = slow.next
+        		fast = fast.next
+        	return slow
+        return None

100-200q/143.py

@@ -0,0 +1,41 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def reorderList(self, head):
+        """
+        :type head: ListNode
+        :rtype: void Do not return anything, modify head in-place instead.
+        """
+        if not head:
+        	return None
+
+        slow, fast = head, head.next
+
+        while fast and fast.next:
+        	slow = slow.next
+        	fast = fast.next.next
+
+        head1, head2 = head, slow.next
+        slow.next = None
+        prev = None
+        curr = head2
+        while curr:
+        	nex = curr.next
+        	curr.next = prev
+        	prev  = curr
+        	curr = nex
+        head2 = prev
+
+        while head2:
+        	n1 = head1.next
+        	n2 = head2.next
+        	head1.next = head2
+        	head1.next.next = n1
+        	head2 = n2
+        	head1 = head1.next.next
+
+        head = head1

100-200q/144.py

@@ -0,0 +1,69 @@
+'''
+	Given a binary tree, return the preorder traversal of its nodes' values.
+
+	Example:
+
+	Input: [1,null,2,3]
+	   1
+	    \
+	     2
+	    /
+	   3
+
+	Output: [1,2,3]
+	Follow up: Recursive solution is trivial, could you do it iteratively?
+'''
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def preorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        if not root:
+        	return []
+
+        stack, result = [root], []
+        while stack:
+        	element = stack.pop()
+        	result.append(element.val)
+
+        	if element.right:
+        		stack.append(element.right)
+        	if element.left:
+        		stack.append(element.left)
+
+        return result
+
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def preorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        result = []
+
+        def recursive(root, result):
+        	if not root:
+        		return 
+        	result.append(root.val)
+        	recursive(root.left, result)
+        	recursive(root.right, result)
+
+        recursive(root, result)
+        return result

100-200q/145.py

@@ -0,0 +1,82 @@
+'''
+	Given a binary tree, return the postorder traversal of its nodes' values.
+
+	Example:
+
+	Input: [1,null,2,3]
+	   1
+	    \
+	     2
+	    /
+	   3
+
+	Output: [3,2,1]
+	Follow up: Recursive solution is trivial, could you do it iteratively?
+'''
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def postorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        
+        result = []
+
+        def recursive(root, result):
+        	if not root:
+        		return
+        	recursive(root.left, result)
+        	recursive(root.right, result)
+        	result.append(root.val)
+        recursive(root, result)
+        return result
+
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def postorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+
+        if not root:
+        	return []
+
+        stack, result = [], []
+
+        while True:
+        	while root:
+        		if root.right:
+        			stack.append(root.right)
+        		stack.append(root)
+        		root = root.left
+
+        	root = stack.pop()
+
+        	if root.right and stack and stack[-1] == root.right:
+        		stack.pop()
+        		stack.append(root)
+        		root = root.right
+        	else:
+        		result.append(root.val)
+        		root = None
+
+        	if  len(stack)<=0:
+        		break
+
+        return result

100-200q/147.py

@@ -0,0 +1,33 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def insertionSortList(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+
+        if not head:
+        	return None
+
+        sortedList = head
+        head = head.next
+        sortedList.next = None
+
+        while head:
+        	curr = head
+        	head = head.next
+        	if curr.val <= sortedList.val:
+        		curr.next = sortedList
+        		sortedList = curr
+        	else:
+        		temp = sortedList
+        		while temp.next and temp.next.val < curr.val:
+        			temp = temp.next
+        		curr.next = temp.next
+        		temp.next = curr
+        return sortedList

300-400q/387.py

@@ -16,10 +16,6 @@ def firstUniqChar(self, s):
         :type s: str
         :rtype: int
         """
-        if not s:
-        	return -1
-
-        for index, char in enumerate(s):
-        	if s.count(char) == 1:
-        		return index
-        return -1
+        letters='abcdefghijklmnopqrstuvwxyz'
+        index=[s.index(l) for l in letters if s.count(l) == 1]
+        return min(index) if len(index) > 0 else -1