7.30笔记

445. 两数相加 II

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        if not l1 and not l2:
            return None
        a = 0 
        b = 0
        l3 = ListNode(None)
        while l1:
            a = a*10 + l1.val
            l1 = l1.next
        while l2:
            b = b*10 + l2.val
            l2 = l2.next
        c = a + b
        cur = l3
        for i in str(c):
            cur.next = ListNode(int(i))
            cur = cur.next
        return l3.next

450. 删除二叉搜索树中的节点

class Solution(object):
    def deleteNode(self, root, key):
        """
        :type root: TreeNode
        :type key: int
        :rtype: TreeNode
        """
        if not root:
            return None
        if root.val > key:
            root.left = self.deleteNode(root.left,key)
        elif root.val < key:
            root.right = self.deleteNode(root.right,key)
        else:
            if not root.left or not root.right:
                root = root.left if root.left else root.right
            else:
                cur = root.right
                while cur.left:
                    cur = cur.left
                root.val = cur.val
                root.right = self.deleteNode(root.right,cur.val)
        return root

449. 序列化和反序列化二叉搜索树

class Codec:
    #先序递归序列化
    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        def preorder(root):
            out = []
            if root:
                out += [str(root.val)]
                out += preorder(root.left)
                out += preorder(root.right)
            return out
        return ','.join(preorder(root))
        
    #二叉搜索树排序之后就是中序，利用先序和中序反序列化
    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if not data:
            return None
        def buildtree(pre,mid):
            if not pre:
                return None
            m = pre[0]
            i = mid.index(m)
            root = TreeNode(m)
            root.left = buildtree(pre[1:i+1],mid[:i])
            root.right = buildtree(pre[i+1:],mid[i+1:])
            return root
        pre = list(map(int,data.split(',')))
        mid = sorted(pre)
        return buildtree(pre,mid)