Depth First Search and Breadth First Search Algorithm to Compute the Left Side View of a Binary Tree

/**
 * class Tree {
 *     public:
 *         int val;
 *         Tree *left;
 *         Tree *right;
 * };
 */
vector<int> solve(Tree* root) {
    if (!root) return {};
    vector<int> ans;
    function<void(Tree*, int)> dfs = [&](Tree* root, int level) {
        if (!root) return;
        // first time which is the left-most node
        if (level >= ans.size()) {
            ans.push_back(root->val);
        }
        dfs(root->left, level + 1);
        dfs(root->right, level + 1);
    };
    dfs(root, 0);
    return ans;
}

# class Tree:
#     def __init__(self, val, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def solve(self, root):
        ans = []
        def dfs(root, level):
            if root is None:
                return
            # first time left-most node
            if len(ans) <= level:
                ans.append(root.val)
            dfs(root.left, level + 1)
            dfs(root.right, level + 1)
        dfs(root, 0)
        return ans

/**
 * class Tree {
 *     public:
 *         int val;
 *         Tree *left;
 *         Tree *right;
 * };
 */
vector<int> solve(Tree* root) {
    if (!root) return {};
    queue<Tree*> Q;
    Q.push(root);
    vector<int> res{};
    while (!Q.empty()) {
        auto sz = Q.size();
        // first node in the queue is the left-most node
        auto p = Q.front();
        res.push_back(p->val);
        for (auto i = 0; i < sz; ++ i) {
            auto p = Q.front();
            if (p->left) {
                Q.push(p->left);
            }
            if (p->right) {
                Q.push(p->right);
            }
            Q.pop();
        }
    }
    return res;
}

# class Tree:
#     def __init__(self, val, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def solve(self, root):
        if root is None:
            return []
        ans = []
        q = [root]
        while len(q) > 0:
            sz = len(q)
            ans.append(q[0].val)
            for i in range(sz):
                p = q.pop(0)
                if p.left:
                    q.append(p.left)
                if p.right:
                    q.append(p.right)
        return ans