LeetCode刷题|day17 二叉树

110. 平衡二叉树 - 力扣（LeetCode）

 平衡二叉树：二叉树中任何节点左右子树的高度差不超过1。

此题使用后序遍历。

 递归三部曲：
1、明确递归函数的参数和返回值

参数：当前传入节点。返回值：以当前传入节点为根节点的树的高度。

如何标记左右子树是否差值大于一？

如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度就没有意义了，所以可以返回-1来标记已经不符合平衡树的规则。

// -1 表示已经不是平衡二叉树了，否则返回值是以该节点为根节点树的高度
int getHeight(TreeNode* node)

2、明确终止条件

递归过程中依然是遇到空节点为终止，返回0，表示当前节点为根节点的树高度为0；

if (node == NULL) {
    return 0;
}

3、明确单层递归逻辑

 分别求出其左右子树的高度，如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树。

int leftHeight = getHeight(node->left); // 左
if (leftHeight == -1) return -1;
int rightHeight = getHeight(node->right); // 右
if (rightHeight == -1) return -1;

int result;
if (abs(leftHeight - rightHeight) > 1) {  // 中
    result = -1;
} else {
    result = 1 + max(leftHeight, rightHeight); // 以当前节点为根节点的树的最大高度
}

return result;

 总结：求二叉树的深度适合用前序遍历，而求高度适合用后续遍历。

 257. 二叉树的所有路径 - 力扣（LeetCode）

 由于此题要求是是从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。此题主要是用到递归和回溯的思想，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径。

递归法

1.递归函数参数以及返回值

要传入根节点，记录每一条路径的path，和存放结果集的result，这里递归不需要返回值：

void traversal(TreeNode* cur, vector<int>& path, vector<string>& result)

 2.确定递归终止条件

本题要找到叶子结点，才开始结束的处理逻辑（把路径放进result里）。当cur不为空，其左右孩子都为空的时候，说明找到了叶子结点（需要判断cur是否为空，不过在此处没有进行判断）。这里使用vector结构path来记录路径，使用要把vector结构的path转换成string格式，再把这个string放进result中。为何使用vector结构做回溯？ 因为在下面处理单层递归逻辑的时候，要做回溯，使用vector方便来做回溯。

if (cur->left == NULL && cur->right == NULL) { // 遇到叶子节点
    string sPath;
    for (int i = 0; i < path.size() - 1; i++) { // 将path里记录的路径转为string格式
        sPath += to_string(path[i]);
        sPath += "->";
    }
    sPath += to_string(path[path.size() - 1]); // 记录最后一个节点（叶子节点）
    result.push_back(sPath); // 收集一个路径
    return;
}

3.确定单层递归逻辑

因为是前序遍历，需要处理中间节点，中间节点就是我们要记录路径上的节点，先放进path中。 由于在确定递归终止条件时，并没有判断cur是否为空，在单层递归时，如果为空就不进行下一层递归了。

所以递归前要加上判断语句，下面要递归的节点是否为空：

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

总体实现：

class Solution {
public:
    void traversal(TreeNode* node, vector<int>& path, vector<string>& result){
        path.push_back(node->val);
        if(node->left==NULL&&node->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(node->left){
            traversal(node->left,path,result);
            path.pop_back();
        }
        if(node->right){
            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> binaryTreePaths(TreeNode* root) {
        stack<TreeNode*> treeSt;// 保存树的遍历节点
        stack<string> pathSt;   // 保存遍历路径的节点
        vector<string> result;  // 保存最终路径集合
        if (root == NULL) return result;
        treeSt.push(root);
        pathSt.push(to_string(root->val));
        while (!treeSt.empty()) {
            TreeNode* node = treeSt.top(); treeSt.pop(); // 取出节点 中
            string path = pathSt.top();pathSt.pop();    // 取出该节点对应的路径
            if (node->left == NULL && node->right == NULL) { // 遇到叶子节点
                result.push_back(path);
            }
            if (node->right) { // 右
                treeSt.push(node->right);
                pathSt.push(path + "->" + to_string(node->right->val));
            }
            if (node->left) { // 左
                treeSt.push(node->left);
                pathSt.push(path + "->" + to_string(node->left->val));
            }
        }
        return result;
    }
};

 404. 左叶子之和 - 力扣（LeetCode）

 要想解此题，需要知道左叶子是什么。左叶子定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点。

判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子。

 递归法（使用后序遍历，因为要通过递归函数的返回值来累加求取左叶子数值之和）

1.确定递归函数的参数和返回值

参数：树的根节点；返回值：左叶子节点之和。

int traversal(TreeNode* node)

 2.确定终止条件

如果遍历到空节点，那么左叶子值一定是0

if(node==NULL) return 0;

注意！只有当前遍历的节点是父节点，才能判断其子节点是不是左叶子。所以若当前遍历的节点是叶子节点，那么其左叶子也必定是0，那么终止条件为：

if(node==NULL) return 0;

if(node->left == NULL && node->right == NULL) return 0;

3.确定单层递归逻辑

当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和和右子树左叶子之和，相加便是整个树的左叶子之和。

int leftnum = traversal(node->left);    // 左
if (node->left && !node->left->left && !node->left->right) {
    leftnum = node->left->val;
}
int rightnum = traversal(node->right);  // 右

int sum = leftnum + rightnum;               // 中
return sum;

 整体代码如下：

class Solution {
public:
    int traversal(TreeNode* node){
        if(node==NULL) return 0;
        if(node->right==NULL&&node->left==NULL) return 0;
        int leftnum=traversal(node->left);
        if(node->left!=NULL&&node->left->left==NULL&&node->left->right==NULL){
            leftnum = node->left->val;
        }
        int rightnum = traversal(node->right);
        int sum = leftnum + rightnum;
        return sum;
    }
    int sumOfLeftLeaves(TreeNode* root) {
        return traversal(root);
    }
};