代码随想录算法训练营第十七天|110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和

题目：110.平衡二叉树

文章链接：代码随想录

视频链接：LeetCode:110.平衡二叉树

题目链接：力扣题目链接

解法1：递归

class Solution {
public:
    int getheight(TreeNode* node){
        // 终止条件，当前节点为空时，返回深度为0
        if(node == NULL) return 0;
        int leftheight = getheight(node->left); 
        int rightheight = getheight(node->right); // 遍历每一个节点
        // 当放回-1时表示，已经不是平衡二叉树了，向上返回-1
        if(leftheight == -1) return -1;
        if(rightheight== -1) return -1;
        // 计算左右节点的差值小于1，则返回最大的高度再加自身
        if(abs(leftheight-rightheight)<=1) return max(leftheight,rightheight)+1;
        else {
            return -1;
        }  
    }
    bool isBalanced(TreeNode* root) {
         return getheight(root)==-1? false:true;
    }
};

总结：

深度是从上往下，到叶子节点的距离，用前序遍历，一直往下，不需要进行返回

高度是从下往上，到根节点的距离，用后序遍历，需要给父节点返回值

因为需要比较左右节点的高度差，需要用高度进行统计

题目：257. 二叉树的所有路径

 文章链接：代码随想录

视频链接：LeetCode:257.二叉树的所有路径

题目链接：力扣题目链接

解法1：

class Solution {
public:
    // 不需要返回值，int数组记录遍历过程，result数组记录每个结果路径
    void traversal(TreeNode* node, vector<int>& path, vector<string>& result){
        //前序遍历  但是当遍历到叶子节点就终止了，所以把节点放入要放在终止处理之前
        path.push_back(node->val);

        // 当遍历到叶子节点进行终止处理
        if(node->left == NULL && node->right == NULL){
            string stringpath; // 定义一个字符串接受路径
            // 遍历到倒数第二个，因为最后一个处理方式不同，不用再加->  [1,2,3]
            for(int i=0; i<path.size()-1; i++){
                stringpath += to_string(path[i]);
                stringpath += "->";    
            }
            // string "1->2->"
            // 加上最后一个路径
            stringpath += to_string(path[path.size()-1]); // string "1->2->3"
            result.push_back(stringpath);
            return;
        }
        // 处理层逻辑
        // 因为遍历到叶子节点就终止了，所以当前节点不能为空，不然node->left就会访问空指针，所以需要加判断
        if(node->left){
            // 递归一层层往下 path [1]->[1,2]->[1,2,4]->[1,2,4,7]到叶子节点开始返回，返回[1,2,4,7]
            traversal(node->left, path, result);
            // 回溯 [1,2,4] 把元素7踢出去
            path.pop_back();
        }
        if(node->right){
            // 走另一条路，把8加进去 [1,2,4,8]
            traversal(node->right, path, result);
            // 回溯
            path.pop_back();
        }
    }

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

奇奇怪怪解法：

class Solution {
public:
    vector<string>result;
    // 二叉树的所有路径
void TreePaths(TreeNode* root,string paths) {
	// 终止条件,碰到叶子节点，把自身路径加上，再返回
	if (root->left == NULL&&root->right == NULL) {
		paths += to_string(root->val); //需不需要int2string
		result.push_back(paths);
		return;
	}
	// 前序，处理中间节点
	paths += to_string(root->val);
	if (root->left != NULL) {
        // 
		TreePaths(root->left, paths+"->");
	}
	if (root->right != NULL) {
		TreePaths(root->right, paths+"->");
	}
	return;
}
    
    vector<string> binaryTreePaths(TreeNode* root) {
        string paths;
        TreePaths(root,paths);
        return result;
    }
};

题目：404.左叶子之和

 文章链接：代码随想录

视频链接：LeetCode:404.左叶子之和

题目链接：力扣题目链接

解法1：递归，要统计数量之和，需要向上返回数值

class Solution {
public:
    // 左叶子之和
int sumOfLeftLeaves(TreeNode* root) {
	// 首先需要判断何为左叶子，自身节点时，无法判断自身是否是左叶子节点
	if (root == NULL) return 0;
	// 遍历到叶子节点时，向上返回0
	if (root->left == NULL && root->right == NULL) return 0;
	// 只有在左叶子节点的父节点，才做统计
	int leftnums = sumOfLeftLeaves(root->left);  //  遍历左边
	int rightnums = sumOfLeftLeaves(root->right); // 遍历右边
	// 中间，判断当前节点是否是都有左叶子节点
	int midnums = 0;
	if (root->left && !root->left->left && !root->left->right) {
		midnums = root->left->val;
	}
	return leftnums + rightnums + midnums;
}
};