leetcode - 刷题记录-探索中级算法-树和图

中序遍历二叉树

给定一个二叉树，返回它的中序遍历。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        res = []
        if root.left is not None:
            res.extend(self.inorderTraversal(root.left))
        res.append(root.val)
        if root.right is not None:
            res.extend(self.inorderTraversal(root.right))
        return res

通过。迭代算法没有实现。

二叉树的锯齿形层次遍历

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    
    def ori_zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        if root.left is None and root.right is None:
            return [[root.val]]
        
        left = self.ori_zigzagLevelOrder(root.left) if root.left is not None else []
        right = self.ori_zigzagLevelOrder(root.right) if root.right is not None else []
        res = [[root.val]]
        if left == []:
            res.extend(right)
            return res
        if right == []:
            res.extend(left)
            return res
        while 1:
            res.append(left[0]+right[0])
            left = left[1:]
            right = right[1:]
            if left == [] or right ==[]:
                break
        res.extend(left)
        res.extend(right)
        return res
    
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        
        if not root:
            return []
        res = self.ori_zigzagLevelOrder(root)
        for i in range(1,len(res),2):
            res[i] = res[i][::-1]
        print(res)
        return res

通过。但有优化空间。

从前序与中序遍历序列构造二叉树

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if len(inorder) == 3 and preorder[1:] == [inorder[0],inorder[-1]]:
            root = TreeNode(preorder[0])
            root.left = TreeNode(preorder[1])
            root.right = TreeNode(preorder[-1])
            return root
        if len(inorder) == 2:
            if preorder == inorder:
                root = TreeNode(preorder[0])
                root.right = TreeNode(preorder[-1])
                return root
            else:
                root = TreeNode(preorder[0])
                root.left = TreeNode(preorder[-1])
                return root
        if len(inorder) == 1:
            return TreeNode(preorder[0])
        if len(inorder) == 0:
            return None
        
        root = TreeNode(preorder[0])
        root_ind = inorder.index(preorder[0])
        if root_ind == len(inorder)-1:
            # only left
            left_in = inorder[:-1]
            left_pre = preorder[1:]
            root.left = self.buildTree(left_pre,left_in) 
            return root
        if  root_ind == 0:
            # only right
            right_in = inorder[1:]
            right_pre = preorder[1:]
            root.right = self.buildTree(right_pre,right_in)
            return root
        else:
            left_in = inorder[:root_ind]
            left_pre = preorder[1:1+len(left_in)]
            right_in = inorder[root_ind+1:]
            right_pre = preorder[-len(right_in):]
            root.left = self.buildTree(left_pre,left_in) 
            root.right = self.buildTree(right_pre,right_in)
            return root

通过

填充每个节点的下一个右侧节点指针

二叉搜索树中第K小的元素

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self,root):
        if not root:
            return []
        if root.left is None and root.right is None:
            return [root.val]
        res = []
        res.extend(self.inorderTraversal(root.left))
        res.append(root.val)
        res.extend(self.inorderTraversal(root.right))
        return res
    
    def kthSmallest(self, root: TreeNode, k: int) -> int:
        
        if root.left is None and root.right is None:
            return root.val
        
        left = self.inorderTraversal(root.left) if root.left is not None else []
        if k <= len(left):
            return left[k-1]
        elif k == len(left)+1:
            return root.val
        else:
            k = k-len(left)-2
        right = self.inorderTraversal(root.right)
        return right[k]

通过

岛屿数量

qq_32110859

发布了45 篇原创文章 · 获赞 1 · 访问量 8554

私信关注

leetcode - 刷题记录-探索中级算法-树和图

猜你喜欢