2021-07-20:二叉树2

 

答案：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findBottomLeftValue(self, root: TreeNode) -> int:
        self.levelnode = []
        self.dfs(root,0)
        print(self.levelnode)
        self.lastlevel = self.levelnode[-1]
        return self.lastlevel[0]
    def dfs(self,pnode,level):
        if not pnode:
            return
        if level < len(self.levelnode):
            self.levelnode[level].append(pnode.val)
        else:
            self.levelnode.append([pnode.val])
        self.dfs(pnode.left,level+1)
        self.dfs(pnode.right,level+1)

 注意list后面添加的区别：

levelnode = [[]]
levelnode.append([1])
levelnode[1].append(2)
levelnode.append([2])
print(levelnode)

D:\study\anaconda\anaconda\python.exe D:/study/untitled/venv/test04.py
[[], [1, 2], [2]]

Process finished with exit code 0

levelnode = []
levelnode.append([1])
levelnode[0].append(2)
levelnode.append([2])
print(levelnode)

D:\study\anaconda\anaconda\python.exe D:/study/untitled/venv/test04.py
[[1, 2], [2]]

Process finished with exit code 0

非递归：  用栈来前序遍历：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        nodes,res = [root],[]
        while nodes:
            node = nodes.pop()
            if node:
                res.append(node.val)
                if node.right:
                    nodes.append(node.right)
                if node.left:
                    nodes.append(node.left)
        return res

 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:
        if not root:
            return
        if root.val >high:
            root = self.trimBST(root.left,low,high)
        elif root.val <low:
            root = self.trimBST(root.right,low,high)
        else:
            root.left = self.trimBST(root.left,low,high)
            root.right = self.trimBST(root.right,low,high)
        return root

 

 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def kthSmallest(self, root: TreeNode, k: int) -> int:
        self.kmin = []
        heapq.heapify(self.kmin)
        self.addvaluetoheap(root,k)
        print(self.kmin)
        return -heapq.heappop(self.kmin)
    def addvaluetoheap(self,pnode,k):
        if not pnode:
            return
        heapq.heappush(self.kmin,-pnode.val)
        if len(self.kmin) > k:
            heapq.heappop(self.kmin)
        self.addvaluetoheap(pnode.left,k)
        self.addvaluetoheap(pnode.right,k)