366. Find Leaves of Binary Tree

Given a binary tree, collect a tree’s nodes as if you were doing this: Collect and remove all leaves, repeat until the tree is empty.

Example:

Input: [1,2,3,4,5]
  
          1
         / \
        2   3
       / \     
      4   5    

Output: [[4,5,3],[2],[1]]
 

Explanation:

1. Removing the leaves [4,5,3] would result in this tree:

          1
         / 
        2          
 

2. Now removing the leaf [2] would result in this tree:

          1          
 

3. Now removing the leaf [1] would result in the empty tree:

          []         

方法1: dfs

思路：

主要思想有点像nestedList：找到每一层bottom up的深度那么就可以建出一个建出一个深度不断增加的数组of数组，将每一层的数字放进取回的深度里面。需要注意的就是在初始化的时候result不知道深度会达到多少，要按需增加，所以要在push之前检查调回的深度是否已经大于当前大小。

class Solution {
public:
    vector<vector<int>> findLeaves(TreeNode* root) {
        vector<vector<int>> result;
        leavesHelper(root, result);
        return result;
    }
    
    int leavesHelper(TreeNode* root, vector<vector<int>> & result){
        if (!root) return -1;
        
        int depth_left = leavesHelper(root -> left, result);
        int depth_right = leavesHelper(root -> right, result);
        
        int depth = max(depth_left, depth_right) + 1;
        if (result.size() == depth) result.push_back({});
        result[depth].push_back(root -> val);
        
        return depth;
    }
};

方法2: peel the onion

思路：

多次dfs遍历，每次剥掉一层皮，将新皮放到result中

易错点

1. 每次循环结束一定要将返回节点重新赋值给它自己！才能实现原位修改。也就是root = ， root->left = , root->right = 新pointer的操作

Complexity

Time complexity: O(nlogn) ? 为什么反而快很多
Space complexity: O(h)

class Solution {
public:
    vector<vector<int>> findLeaves(TreeNode* root) {
        vector<vector<int>> result;
        while (root) {
            vector<int> current;
            root =leavesHelper(root, current);
            result.push_back(current);
        }
        
        return result;
    }
    
    TreeNode* leavesHelper(TreeNode* root, vector<int> & current){
        if (!root) return nullptr;
        if (!root -> left && !root -> right) {
            current.push_back(root -> val);
            return nullptr;
        }
        
        root -> left = leavesHelper(root -> left, current);
        root -> right = leavesHelper(root -> right, current);
        
        return root;
    }
};