代码随想录day19day20打卡

二叉树

1 二叉树的最大深度和最小深度

最大深度已经学习过了，实质就是递归的去判断左右子节点的深度，然后对其进行返回。
附加两个学习的部分：
（1）使用前序遍历的方法求解

int result;
void getdepth(TreeNode* node, int depth){
	result = depth > result ? depth : result;
	if(node->left == NULL && node->right==NULL)return ;
	if(node->left){ //左节点深度
		depth++; //深度+1
		getdepth(node->left, depth);
		depth--; //此处需要进行回溯
	}
	if(node->right){
		depth++;
		getdepth(node->right, depth);
		depth--; //此处需要进行回溯	
	}
	return ;
}
int maxDepth(TreeNode* root){
	result = 0;
	if(root == NULL)return result;
	getdepth(root,1);
	return result;
}

(2)迭代法，使用层序遍历
即只需要记录遍历的层数即可

int maxDepth(TreeNode* root){
	if(root == NULL)return 0;
	int depth = 0;
	queue<TreeNode*> que;
	que.push(root);
	while(!que.empty()){
		int size = que.size();
		depth++;
		for(int i = 0;i<size;i++){
			TreeNode* node = que.front();
			que.pop();
			if(node->left)que.push(node->left);
			if(node->right)que.push(node->right);
		}
	}
	return depth;
}

最小深度题目：
在这里插入图片描述

在递归法当中，要注意左子树不存在或者是右子树不存在的问题，其余的按照最大深度的模版套用即可。

//后序遍历
int getDepth(TreeNode* node){
	if(node == NULL)return 0;
	int leftDepth = getDepth(node->left);
	int rightDepth = getDepth(node->right);
	//左空右不空
	if(node->left == NULL && node->right != NULL){
		return 1+rightDepth;
	}
	//右空左不空
	if(node->left != NULL && node->right == NULL){
		return 1+leftDepth;
	}
	if(node->left != NULL && node->right != NULL){
		return 1+min(leftDepth,rightDepth);
	}
}
int minDepth(TreeNode* root){
	return getDepth(root);
}

//前序遍历
class Solution {
private:
    int result;
    void getdepth(TreeNode* node, int depth) {
        // 函数递归终止条件
        if (node == nullptr) {
            return;
        }
        // 中，处理逻辑：判断是不是叶子结点
        if (node -> left == nullptr && node->right == nullptr) {
            result = min(result, depth);
        }
        if (node->left) { // 左
            getdepth(node->left, depth + 1);
        }
        if (node->right) { // 右
            getdepth(node->right, depth + 1);
        }
        return ;
    }

public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        result = INT_MAX;
        getdepth(root, 1);
        return result;
    }
};

迭代法只需增加一个条件，就是到这个节点时，左右子都为空，那么可以返回这个深度。

int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录最小深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }

2 完全二叉树的节点个数

3 平衡二叉树

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

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

示例 1:

给定二叉树 [3,9,20,null,null,15,7]
返回true

复习二叉树节点的深度和高度。

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

一般定义根节点的深度为1。求深度可以从上到下进行查找，需要进行前序遍历（中左右）。而求高度只能从下到上去查，所以只能后序遍历（左右中）。

回顾求取二叉树的最大深度

class solution{
public:
	int result;
	void getDepth(TreeNode* node, int depth){
		result = depth > reusult ? depth : result;
		if(node->left == NULL && node->right == NULL) return ;
		if(node->left){
			depth++;
			getDepth(node->left,depth);
			depth--;
		}
		if(node->right){
			depth++;
			getDepth(node->right,depth);
			depth--;
		}
		return ;
	}
	int maxDepth(TreeNode* root){
		result = 0;
		if(root == NULL)return result;
		getDepth(root, 1);
		return result;
	}
};

递归法
1）明确递归函数的参数和返回值：那么参数一定是当前的节点，并且需要返回以当前传入节点为根节点的树的高度。int getHeight(TreeNode* node)
2）终止条件：既需要遇到空节点。if(node==NULL) return 0;
3）确认单层递归的逻辑：只需要判断左子树和右子树的高度差即可。

int leftHeight = getHeight(node->left);
if(leftHeight == -1)return -1;
int rightHeight= getHeight(node->right);
if(rightHeight== -1)return -1;
int result;
if(ans(leftHeight - rightHeight) > 1) return -1;
else result = 1 + max(leftHeight,rightHeight);
return result;

最终代码：

class Solution {
public:
    // 返回以该节点为根节点的二叉树的高度，如果不是平衡二叉树了则返回-1
    int getHeight(TreeNode* node) {
        if (node == NULL) {
            return 0;
        }
        int leftHeight = getHeight(node->left);
        if (leftHeight == -1) return -1;
        int rightHeight = getHeight(node->right);
        if (rightHeight == -1) return -1;
        return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true;
    }
};

4 二叉树的所有路径（回溯算法）

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

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

在这里插入图片描述
要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。

在这道题目中将第一次涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径。

前序遍历以及回溯的过程如图：
加粗样式
递归回溯法
1）明确递归函数的参数和返回值：需要传入根节点，记录每一条路径的path以及结果集result，不需要返回值。
2）终止条件：既需要遇到节点的左右子均为空。当遇到这个情况的时候，需要将之前遍历的节点存入数组当中，并且还需要将其转化为string，存入result。
3）确认单层递归的逻辑：即遍历过程中需要将遍历的path存入数组，因为是前序遍历，需要先处理中间节点，中间节点就是我们要记录路径上的节点，先放进path中。path.push_back(cur->val);
然后是递归和回溯的过程，上面说过没有判断cur是否为空，那么在这里递归的时候，如果为空就不进行下一层递归了。所以递归前要加上判断语句，下面要递归的节点是否为空，同时需要进行回溯，也就是要把这个path弹出去，如下：

if (cur->left) {
    traversal(cur->left, path, result);
    path.pop_back(); // 回溯
}
if (cur->right) {
    traversal(cur->right, path, result);
    path.pop_back(); // 回溯
}

整体的代码如下：

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;
    }
};

代码精简：

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;

    }
};

5 左叶子之和

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

示例：

在这里插入图片描述
判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子。

如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子

递归回溯法
1）明确递归函数的参数和返回值：需要传入根节点，返回值为数值之和
2）终止条件：遇到空节点，返回0。
3）确认单层递归的逻辑：遇到左叶子存入该值，然后通过递归求取左子树左叶子之和与右子树左叶子之和。

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;
    }