链表相加2&&求根节点到叶节点数字之和&&二叉树剪枝

链表相加2

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    ListNode* addInList(ListNode* head1, ListNode* head2) {
        // write code here
        head1 = merge(head1);
        head2 = merge(head2);
        ListNode* res = cal(head1, head2);
        return merge(res);
    }
    ListNode* cal(ListNode* head1, ListNode* head2){
        auto dumy = new ListNode(0);
        auto head = dumy;
        ListNode* prev = nullptr;
        int c = 0;
        while (head1 && head2) {
            int tmp = c + head1->val + head2->val;
            dumy->val = tmp % 10;
            c = tmp / 10;
            std::cout << tmp << " ";
            head1 = head1->next;
            head2 = head2->next;
            dumy->next = new ListNode(0);
            prev = dumy;
            dumy = dumy->next;
        }
        head1 = head1 == nullptr ? head2 : head1;
        while (head1) {
            int tmp = c + head1->val;
            dumy->val = tmp % 10;
            c = tmp / 10;
            head1 = head1->next;
            dumy->next = new ListNode(0);
            prev = dumy;
            dumy = dumy->next;
        }
        if(c == 0){
            prev->next = nullptr;
            delete dumy;
        }
        else dumy->val = c;
        return head;
    }
    ListNode* merge(ListNode* head){
        if(head == nullptr || head->next == nullptr)    return head;

        ListNode* newhead = merge(head->next);
        head->next->next = head;
        head->next = nullptr;
        return newhead;
    }
};

求根节点到叶节点数字之和

class Solution {
public:
    int sumNumbers(TreeNode* root) { return dfs(root, 0); }

    int dfs(TreeNode* root, int sum) {
        if (root == nullptr)
            return 0;
        // 叶子节点
        if (root->left == nullptr && root->right == nullptr)
            return sum + root->val;
        // 非叶子节点
        int tmp = 10 * (sum + root->val);
        return dfs(root->left, tmp) + dfs(root->right, tmp);
    }
};

二叉树剪枝

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* pruneTree(TreeNode* root) {
        dfs(root);
        return root;
    }
    void dfs(TreeNode*& root) {
        if (root == nullptr)
            return;
        dfs(root->left);
        dfs(root->right);
        
        if (root->left == nullptr && root->right == nullptr) {
            if (root->val == 0)
                root = nullptr;
        }
    }
};

细节：删除节点的时候不建议delete，因为不知道给的节点是不是new出来的