All Possible Full Binary Trees

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:


    TreeNode* deep_copy(TreeNode* root)
    {
        if (root == nullptr)
            return nullptr;

        TreeNode* n_root = new TreeNode(0);
        n_root -> left = deep_copy (root -> left);
        n_root -> right = deep_copy (root -> right);

        return n_root;

    }
    vector<TreeNode*> allPossibleFBT(int N) {

        vector< TreeNode*> res;
        if (N == 1)
        {
            TreeNode *n_node = new TreeNode(0);
            return {n_node};
        }
        if (N % 2 == 0)
        {
            return {};
        }

        for (int cur_root = 2 ; cur_root <= N ; cur_root += 2)
        {
            vector <TreeNode*> ls = allPossibleFBT (cur_root - 1);
            vector <TreeNode*> rs = allPossibleFBT (N - cur_root);

            for (int l_idx = 0 ; l_idx < ls.size(); l_idx++)
            {
                for (int r_idx = 0 ; r_idx < rs.size(); r_idx++)
                {
                    TreeNode *n_node = new TreeNode(0);

                    TreeNode *n_left = (r_idx == rs.size() - 1) ? ls[l_idx] : deep_copy (ls[l_idx]);
                    TreeNode *n_right = (l_idx == ls.size() - 1) ? rs[r_idx] : deep_copy (rs[r_idx]);

                    n_node -> left = n_left;
                    n_node -> right = n_right;

                    res.push_back (n_node);

                }
            }
        }
        return res;

    }
};