110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和

力扣题目链接(opens new window)

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

class Solution {
public:
    int getHe(TreeNode* node){
        if(node==NULL)return 0;
        int leftH = getHe(node->left);
        if(leftH==-1)return -1;
        int rightH = getHe(node->right);
        if(rightH==-1)return -1;

        int result;
        if(abs(leftH-rightH)>1){
            result = -1;
        }else{
            result = 1 + max(leftH,rightH);
        }
        return result;

    }
    bool isBalanced(TreeNode* root) {
        return getHe(root) == -1 ? false : true;

    }
};

运用递归 函数返回值是该节点的高度

先确定终止条件 node==NULL说明到空节点没有高度 返回0

先取得左节点高度 再取得右节点高度 如果高度值为-1直接 return -1

求左右节点的高度差 取绝对值 如果高度差大于1则让result= -1

如果正常则返回该节点高度result

257. 二叉树的所有路径

力扣题目链接(opens new window)

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

// 版本一
class Solution {
private:

    void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {
        path.push_back(cur->val); // 中，中为什么写在这里，因为最后一个节点也要加入到path中 
        // 这才到了叶子节点
        if (cur->left == NULL && cur->right == NULL) {
            string sPath;
            for (int i = 0; i < path.size() - 1; i++) {
                sPath += to_string(path[i]);
                sPath += "->";
            }
            sPath += to_string(path[path.size() - 1]);
            result.push_back(sPath);
            return;
        }
        if (cur->left) { // 左 
            traversal(cur->left, path, result);
            path.pop_back(); // 回溯
        }
        if (cur->right) { // 右
            traversal(cur->right, path, result);
            path.pop_back(); // 回溯
        }
    }

public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        vector<int> path;
        if (root == NULL) return result;
        traversal(root, path, result);
        return result;
    }
};

递归的终止条件是找到叶子节点 并没有判断节点是否为空 所以需要判断左右是否存在 因为找到路径后还需要删除路径回到根节点找下一条路径 所以需要pop回溯

return只是终止本次回溯

精简：

class Solution {
private:

    void traversal(TreeNode* cur, string path, vector<string>& result) {
        path += to_string(cur->val); // 中
        if (cur->left == NULL && cur->right == NULL) {
            result.push_back(path);
            return;
        }
        if (cur->left) traversal(cur->left, path + "->", result); // 左
        if (cur->right) traversal(cur->right, path + "->", result); // 右
    }

public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        string path;
        if (root == NULL) return result;
        traversal(root, path, result);
        return result;

    }
};

path是复制的 不用pop 因为当前层用到的path没有改变

404.左叶子之和

力扣题目链接(opens new window)

计算给定二叉树的所有左叶子之和。

前序遍历找到目标值就加上即可

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> st;
        if (root == NULL) return 0;
        st.push(root);
        int result = 0;
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
                result += node->left->val;
            }
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return result;
    }
};

递归：

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right== NULL) return 0;

        int leftValue = sumOfLeftLeaves(root->left);    // 左
        if (root->left && !root->left->left && !root->left->right) { // 左子树就是一个左叶子的情况
            leftValue = root->left->val;
        }
        int rightValue = sumOfLeftLeaves(root->right);  // 右

        int sum = leftValue + rightValue;               // 中
        return sum;
    }
};

只能通过目标节点的父亲判断是否满足条件

终止条件：空节点不满足条件 普通的叶子节点不满足条件

int rightValue直接进入下一层递归判断 最后一顿递归将值返回给rightValue

还是不太理解。。