Partial Old questions

Author: YuduDu

linkedlist/148. Sort List - EricD.py

@@ -0,0 +1,49 @@
+#iteration:
+def sortList(self, head):
+    """
+    :type head: ListNode
+    :rtype: ListNode
+    """
+    if (not head) or (not head.next):
+        return head
+    slow = fast = head
+    while fast.next and fast.next.next:
+        fast = fast.next.next
+        slow = slow.next
+    
+    p1 = self.sortList(slow.next)
+    slow.next = None
+    p2 = self.sortList(head)
+    
+    p = res = ListNode(None)
+    while p1 and p2:
+        if p1.val<p2.val:
+            p.next = p1
+            p1 = p1.next
+            p = p.next
+        else:
+            p.next = p2
+            p2 = p2.next
+            p = p.next
+    if p1:
+        p.next = p1
+    if p2:
+        p.next = p2
+    return res.next
+
+#array...
+def sortList(self, head):
+    """
+    :type head: ListNode
+    :rtype: ListNode
+    """
+    items = []
+    while head:
+        items.append(head.val)
+        head = head.next
+    items.sort()
+    p = res = ListNode(None)
+    for i in items:
+        p.next = ListNode(i)
+        p = p.next
+    return res.next

linkedlist/2. Add Two Numbers -EricD.py

@@ -0,0 +1,27 @@
+def addTwoNumbers(self, l1, l2):
+    """
+    :type l1: ListNode
+    :type l2: ListNode
+    :rtype: ListNode
+    """
+    l3 = res = ListNode(None)
+    p=0
+    while l1 and l2:
+        n,p = (l1.val+l2.val+p)%10,(l1.val+l2.val+p)/10
+        l3.next = ListNode(n)
+        l3 = l3.next
+        l1 = l1.next
+        l2 = l2.next
+    while l1:
+        n,p = (l1.val+p)%10,(l1.val+p)/10
+        l3.next = ListNode(n)
+        l3 = l3.next
+        l1 = l1.next
+    while l2:
+        n,p = (l2.val+p)%10,(l2.val+p)/10
+        l3.next = ListNode(n)
+        l3 = l3.next
+        l2 = l2.next
+    if p>0:
+        l3.next = ListNode(p)
+    return res.next

linkedlist/445. Add Two Numbers II - EricD.py

@@ -0,0 +1,20 @@
+def addTwoNumbers(self, l1, l2):
+    """
+    :type l1: ListNode
+    :type l2: ListNode
+    :rtype: ListNode
+    """
+    n1,n2=0,0
+    while l1:
+        n1 = n1*10+l1.val
+        l1 = l1.next
+    while l2:
+        n2 = n2*10+l2.val
+        l2 = l2.next
+    
+    sum = str(n1+n2)
+    cur = res = ListNode(None)
+    for n in sum:
+        cur.next =ListNode(n)
+        cur = cur.next
+    return res.next

tree/EricD/100. Same Tree - EricD.py

@@ -0,0 +1,12 @@
+def isSameTree(self, p, q):
+    """
+    :type p: TreeNode
+    :type q: TreeNode
+    :rtype: bool
+    """
+    if p is None and q is None:
+        return True
+    elif not (p and q):
+        return False
+    else:
+        return (p.val == q.val) and self.isSameTree(p.left, q.left) and self.isSameTree(p.right,q.right)

tree/EricD/104. Maximum Depth of Binary Tree - EricD.py

@@ -0,0 +1,6 @@
+def maxDepth(self, root):
+    """
+    :type root: TreeNode
+    :rtype: int
+    """
+    return max(self.maxDepth(root.left),self.maxDepth(root.right))+1 if root else 0

tree/EricD/111. Minimum Depth of Binary Tree - EricD.py

@@ -0,0 +1,37 @@
+#DFS
+def minDepth(self, root):
+    """
+    :type root: TreeNode
+    :rtype: int
+    """
+    if root:
+        if root.left is None and root.right is None:
+            return 1
+        else:
+            l = self.minDepth(root.left) if root.left else sys.maxint
+            r = self.minDepth(root.right) if root.right else sys.maxint
+            return min(l,r)+1
+            
+    else:
+        return 0
+
+#BFS
+def minDepth(self, root):
+    """
+    :type root: TreeNode
+    :rtype: int
+    """
+    if root:
+        level = 0
+        cur = [root]
+        while cur:
+            level+=1
+            nextR = []
+            for node in cur:
+                if node.left is None and node.right is None:
+                    return level
+                if node.left: nextR.append(node.left)
+                if node.right: nextR.append(node.right)
+            cur = nextR
+    else:
+        return 0

tree/EricD/235. Lowest Common Ancestor of a Binary Search Tree - EricD.py

@@ -0,0 +1,11 @@
+# Binary Search Tree! 
+def lowestCommonAncestor(self, root, p, q):
+    """
+    :type root: TreeNode
+    :type p: TreeNode
+    :type q: TreeNode
+    :rtype: TreeNode
+    """
+    while (root.val-p.val)*(root.val-q.val)>0:
+        root = root.left if root.val>q.val else root.right
+    return root

tree/EricD/394. Decode String - EricD.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    def decodeString(self, s):
+        """
+        :type s: str
+        :rtype: str
+        """
+        stack = []
+        for i in s:
+            if i != ']':
+                stack.append(i)
+            else:
+                word = []
+                while stack[-1] != '[':
+                    word.append(stack.pop())
+                stack.pop()
+                freq = []
+                while stack and stack[-1].isdigit():
+                    freq.append(stack.pop())
+                k=''.join(freq[::-1])
+                w  = ''.join(word[::-1])
+                stack.append(w*int(k))
+            
+        return ''.join(stack)
+            

tree/EricD/538. Convert BST to Greater Tree - EricD.py

@@ -0,0 +1,28 @@
+# 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 __init__(self):
+        self.sum=0
+            
+    def convertBST(self, root):
+        """
+        :type root: TreeNode
+        :rtype: TreeNode
+        """
+        k=[0]
+        
+        if not root:
+            return root
+        if root.right:
+            self.convertBST(root.right)
+        root.val+=self.sum
+        self.sum=root.val
+        if root.left:
+            self.convertBST(root.left)
+        return root
+