算法60天：day18

1、确定递归函数的参数和返回值
2、确定终止条件
3、确定单层递归的逻辑

/**
* 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:
    int maxDepth = INT_MIN;
    int result;
    void traversal(TreeNode* node,int depth){
        if(node->left == nullptr && node->right == nullptr){
            if(depth > maxDepth){
                maxDepth = depth;
                result = node->val;
            }
        }
        if(node->left){
            depth++;
            traversal(node->left,depth);
            depth--;
        }
        if(node->right){
            depth++;
            traversal(node->right,depth);
            depth--;
        }
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root,0);
        return result;
    }
};

二叉树-路径总和

力扣

class Solution {
public:
    bool traversal(TreeNode* root,int count){
        if(root->left == nullptr && root->right == nullptr && count == 0){
            return true;
        }
        if(root->left == nullptr && root->right == nullptr){
            return false;
        }
        if(root->left){
            count -= root->left->val;
            if(traversal(root->left,count)) return true;
            count += root->left->val; 
        }
        if(root->right){
            count -= root->right->val;
            if(traversal(root->right,count)) return true;
            count += root->right->val; 
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return false;
        return traversal(root,targetSum - root->val);
    }
};

/*利用之前求路径的方法*/
class Solution {
public:
    bool result = false;
    void preOrder(TreeNode* node,vector<int>& vec,int targetSum){
        vec.push_back(node->val);
        if(node->left == nullptr && node->right == nullptr){
            int sum = 0;
            for(int i : vec){
                sum += i;
            }
            if(sum == targetSum){
                result = true;
            }
            return;
        }
        if(node->left){
            preOrder(node->left,vec,targetSum);
            vec.pop_back();
        }
        if(node->right){
            preOrder(node->right,vec,targetSum);
            vec.pop_back();
        }
        return;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return result;
        vector<int> vec;
        preOrder(root,vec,targetSum);
        return result;
    }
};

二叉树-左叶子之和

力扣

class Solution {
public:
    //1、确定递归的参数和返回值，如果返回-1表示不是平衡二叉树
    int getHeight(TreeNode* node){
        //2、确定终止条件
        if(node == nullptr) return 0;
        //3、单层递归逻辑
        int llength = getHeight(node->left);
        if(llength == -1) return -1;
        int rlength = getHeight(node->right);
        if(rlength == -1) return -1;
        return abs(llength - rlength) > 1 ? -1 : 1+max(llength,rlength);
    }
    bool isBalanced(TreeNode* root) {
        if(root == nullptr) return true;
        int res = getHeight(root);
        return res == -1 ? false : true;
    }
};

二叉树-从中序与后序遍历序列构造二叉树

力扣

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder,vector<int>& postorder){
        if (postorder.size() == 0) return NULL;

        //1、后序遍历第二个数组的最后一个，作为中间值
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        //叶子节点
        if(postorder.size() == 1) return root;

        //2、找到中序遍历的切割点
        int delimiterIndex;
        for(int i = 0; i < inorder.size(); i++){
            if(inorder[i] == rootValue){
                delimiterIndex = i;
                break;
            }
        }

        //3、切割中序数组
        //左闭右开区间，[0，delimiterIndex)
        vector<int> leftInorder(inorder.begin(),inorder.begin()+delimiterIndex);
        //[delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin()+delimiterIndex+1,inorder.end());

        //postorder舍弃末尾节点
        // [0, leftInorder.size)
        postorder.resize(postorder.size() - 1);
        //后序的左节点=中序的左节点大小
        // [leftInorder.size(), end)
        vector<int> leftPostorder(postorder.begin(),postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(),postorder.end());

        root->left = traversal(leftInorder,leftPostorder);
        root->right = traversal(rightInorder,rightPostorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0 || postorder.size() == 0) return nullptr;
        return traversal(inorder,postorder);
    }
};

二叉树-从前序与中序遍历序列构造二叉树

力扣

class Solution {
public:
    TreeNode* traversal(vector<int>& preorder,int preorderBegin,int preorderEnd,vector<int>& inorder,int inorderBegin,int inorderEnd){
        if(preorderBegin == preorderEnd) return nullptr;

        int rootValue = preorder[preorderBegin];
        TreeNode* root = new TreeNode(rootValue);

        if(preorderEnd - preorderBegin == 1) return root;

        int delimiterIndex;
        for(delimiterIndex = inorderBegin;delimiterIndex < inorderEnd;delimiterIndex++){
            if(inorder[delimiterIndex] == rootValue){
                break;
            }
        }

        //切割中间序列
        //中序左边,[inorderBegin,delimiterIndex)
        //中序右边,[delimiterIndex,inorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        int rightInorderBegin = delimiterIndex+1;
        int rightInorderEnd = inorderEnd;

        //切割前序列
        int leftpreorderBegin = preorderBegin + 1;
        int leftpreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin;
        int rightpreorderBegin = preorderBegin + 1 + (delimiterIndex - inorderBegin);
        int rightpreorderEnd = preorderEnd;

        root->left = traversal(preorder,leftpreorderBegin,leftpreorderEnd,inorder,leftInorderBegin,leftInorderEnd);
        root->right = traversal(preorder,rightpreorderBegin,rightpreorderEnd,inorder,rightInorderBegin,rightInorderEnd);
        return root;

    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0) return nullptr;
        return traversal(preorder,0,preorder.size(),inorder,0,inorder.size());
    }
};