leetcode-二叉树结构题

最新推荐文章于 2022-06-05 21:07:06 发布

winner8881

最新推荐文章于 2022-06-05 21:07:06 发布

阅读量140

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/qq_22866291/article/details/100530505

版权

数据结构专栏收录该内容

20 篇文章 0 订阅

订阅专栏

遍历方式的变体
dfs的变体

打印二叉树(带null)

方法1：

class Solution(object):
    def print_tree(self, root):
        if not root:
            return []
        queue = [root]
        ret = []
        while queue:
            res = []
            for i in queue:
                if not i:
                    res.append(None)
                    continue
                res.append(i.val)
            ret.append(res)
            size = len(queue)
            for i in range(size):
                cur = queue.pop(0)
                if not cur:
                    continue
                queue.append(cur.left)
                queue.append(cur.right)
        print(ret[:-1])

方法2

class Solution(object):
    def print_tree(self, root):
        if not root:
            return []
        queue = [root]
        ret = []
        while(queue):
            next_queue = list()
            layer = list()
            for node in queue:
                if not node:
                    layer.append(None)
                    continue
                next_queue.append(node.left)
                next_queue.append(node.right)
                
                layer.append(node.val)
            ret.append(layer)
            queue = next_queue
        print(ret[:-1])

617. 合并二叉树

class Solution:
    def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
        if not t1:
            return t2
        if not t2:
            return t1
        t1.val += t2.val
        t1.left = self.mergeTrees(t1.left, t2.left)
        t1.right = self.mergeTrees(t1.right, t2.right)
        return t1

226. 翻转二叉树

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return 
        root.right, root.left = self.invertTree(root.left),self.invertTree(root.right)
        return root

BFS:层序遍历

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return 
        queue = [root]
        while queue:
            cur = queue.pop(0)
            cur.left, cur.right = cur.right, cur.left
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        return root

将有序数组转换为二叉搜索树

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        n = len(nums)
        if not n:
            return 
        mid = n//2
        root = TreeNode(nums.pop(mid))
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid:])
        
        return root

965. 单值二叉树

class Solution:
    def isUnivalTree(self, root: TreeNode) -> bool:
        if not root:
            return False
        queue = [root]
        res = []
        while queue:
            cur = queue.pop(0)
            res.append(cur.val)
            cur.left, cur.right = cur.right, cur.left
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        return len(set(res)) == 1

783. 二叉搜索树结点最小距离

class Solution:
    def minDiffInBST(self, root: TreeNode) -> int:
        queue = [root]
        res = []
        while queue:
            cur = queue.pop(0)
            res.append(cur.val)
            cur.left, cur.right = cur.right, cur.left
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        res.sort()
        val = []
        for i in range(1, len(res)):
            val.append(abs(res[i] - res[i - 1]))
        return min(val)

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

from collections import deque
class Codec:

    def serialize(self, root):
        s = []
        def Ser(root):
            if not root:
                s.append('#')
            else:
                s.append(str(root.val))
                Ser(root.left)
                Ser(root.right)
        Ser(root)
        return ' '.join(s)

    def deserialize(self, data):
        datas=deque(val for val in data.split())        
        def Rev():
            d=datas.popleft()
            if d=='#':
                return None
            root=TreeNode(int(d))
            root.left=Rev()
            root.right=Rev()
            return root
        return Rev()

988. 从叶结点开始的最小字符串

class Solution:
    def smallestFromLeaf(self, root: TreeNode) -> str:
        res = []
        def dfs(root, path):
            if not root:
                return
            if not root.left and not root.right:
                path.append(root.val)
                res.append(path)
            dfs(root.left, path + [root.val])
            dfs(root.right, path + [root.val])
        dfs(root, list())
        val = [''.join([str(i) for i in re]) for re in res]
        ret = []
        dic = {i:chr(ord('a') + i) for i in range(26)}
        for re in res:
            tmp = []
            for i in re[::-1]:
                tmp.append(dic[i])
            ret.append(''.join([str(i) for i in tmp]))
        ret.sort()
        return ret[0]

1008. 先序遍历构造二叉树

class Solution:
    def bstFromPreorder(self, preorder: List[int]) -> TreeNode:
        if not preorder:
            return None
        root = TreeNode(preorder[0]) 
        left, right = [], []
        for x in preorder[1:]:
            if x < root.val:
                left.append(x)
            else:
                right.append(x)
            
        root.left = self.bstFromPreorder(left)
        root.right = self.bstFromPreorder(right)
        return root

106. 从中序与后序遍历序列构造二叉树

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        if not postorder:
            return None
        root = TreeNode(postorder[-1])
        n = inorder.index(root.val)
        root.left = self.buildTree(inorder[:n],postorder[:n])
        root.right = self.buildTree(inorder[n+1:],postorder[n:-1])
        return root

889. 根据前序和后序遍历构造二叉树

class Solution:
    def constructFromPrePost(self, pre: List[int], post: List[int]) -> TreeNode:
        if not pre:
            return None
        root = TreeNode(pre[0])
        if len(pre) == 1:
            return root
        n = post.index(pre[1])
        root.left = self.constructFromPrePost(pre[1:n+2], post[:n+1])
        root.right = self.constructFromPrePost(pre[n+2:], post[n+1:-1])
        return root

101. 对称二叉树

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        queue = [root]
        ret = []
        while queue:
            res = []
            for i in queue:
                if not i:
                    res.append(None)
                    continue
                res.append(i.val)
            ret.append(res)
            size = len(queue)
            for i in range(size):
                cur = queue.pop(0)
                if not cur:
                    continue
                queue.append(cur.left)
                queue.append(cur.right)
        for i in ret[:-1]:
            if i != i[::-1]:
                return False
        print(ret)
        return True

222. 完全二叉树的节点个数

class Solution(object):
    def countNodes(self, root):
        if not root:
            return 0
        queue = [root]
        ret = []
        while queue:
            cur = queue.pop(0)
            ret.append(cur.val)
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        return len(ret)

662. 二叉树最大宽度

class Solution(object):
    def widthOfBinaryTree(self, root):
        if not root:
            return 0
        Max = 0
        queue = [(root,0)]
        while queue:
            length = len(queue)
            wight = queue[-1][1] - queue[0][1] + 1
            Max = max(wight,Max)
            for i in range(length):
                node = queue.pop(0)
                if node[0].left:
                    queue.append((node[0].left,2*node[1]))
                if node[0].right:
                    queue.append((node[0].right,2*node[1]+1))
        return Max

437. 路径总和 III

class Solution(object):
    result = 0
    def mypathsum(self, root, sum):
        if root is None:
            return 
        sum -= root.val
        if sum == 0:
            self.result += 1
        self.mypathsum(root.left, sum)
        self.mypathsum(root.right, sum)
        
    def pathSum(self, root, sum):
        if root is None:
            return 0
        self.mypathsum(root,sum)
        self.pathSum(root.left, sum)
        self.pathSum(root.right, sum)
        return self.result