[Leetcode] 366. Find Leaves of Binary Tree

方法1

DFS: set all leaf indexes as 1, use dfs to get indexes for each node. use dict to store the index -> nodes. get leaves from by indexes.

time complexity: the time for get indexes is O(n)
space complexity: O(n)

class Solution:
    def findLeaves(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        indexes = defaultdict(list)
        self.dfs(root, indexes)
        res = []
        for i in range(len(indexes.keys())):
            res.append(indexes[i])
        return res
    
    def dfs(self, root, indexes):
        if not root:
            return -1
        if not root.left and not root.right:
            indexes[0].append(root.val)
            return 0
        
        left = self.dfs(root.left, indexes)
        right = self.dfs(root.right, indexes)
        curt = max(left, right) + 1
        indexes[curt].append(root.val)
        return curt

方法2

DFS: get leaves and remove leaves in each dfs recursion, until the root is a leaf and set to None
in this process, the tree structure is changed
** Attention: delete leaf 的操作不能直接将当前node设成None,此时只是将当前node的reference指向None，上一层node的left/right reference并没有发生变化。
https://www.geeksforgeeks.org/overview-of-data-structures-set-2-binary-tree-bst-heap-and-hash/ Tree Node的结构

Time complexity: O(n)
Space complexity: O(n)

class Solution:
    def findLeaves(self, root: TreeNode) -> List[List[int]]:
        res = []
        while root:
            level = []
            root = self.dfs(root, level)
            res.append(level)
        return res
    
    def dfs(self, root, leaves):
        if not root:
            return None
        if not root.left and not root.right:
            leaves.append(root.val)
            return None
        root.left = self.dfs(root.left, leaves)
        root.right = self.dfs(root.right, leaves)
        return root

方法3

BFS: BFS + topological sorting
use BFS to build the graph: get in-degree, get leaves with in-degree of 0, get parent of each leaf
use topological sorting from last level leaves to get previous leaves, update in-degree of parent of each leaf

Space and time complexity: O(n)

class Solution:
    def findLeaves(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = []
        last_level = []
        parents = {}
        in_degree = {}
        queue = [root]
        while queue:
            node = queue.pop()
            if not node.left and not node.right:
                last_level.append(node)
                in_degree[node] = 0
            if node.left:
                queue.append(node.left)
                parents[node.left] = node
                in_degree[node] = in_degree.get(node, 0) + 1
            if node.right:
                queue.append(node.right)
                parents[node.right] = node
                in_degree[node] = in_degree.get(node, 0) + 1
        
        while last_level:
            level = []
            for i in range(len(last_level)):
                node = last_level.pop(0)
                level.append(node.val)
                if node in parents:
                    parent = parents[node]
                    in_degree[parent] -= 1
                    if in_degree[parent] == 0:
                        last_level.append(parent)
            res.append(level)
        return res