代码随想录一刷打卡——二叉树（中篇）

---

前言

一个本硕双非的小菜鸡，备战24年秋招，计划刷完卡子哥的刷题计划，加油！
推荐一手卡子哥的刷题网站，感谢卡子哥。代码随想录

一、559. N 叉树的最大深度

559. N 叉树的最大深度
Note：依旧是递归，把每个孩子都放进去一遍就好了

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        if(root == NULL) return 0;
        int depth = 0;
        for (int i = 0; i < root->children.size(); i++)
            depth = max(depth, maxDepth(root->children[i]));
        return depth + 1;
    }
};

二、222. 完全二叉树的节点个数

222. 完全二叉树的节点个数

Note：递归法迭代法均可
递归法

/**
 * 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 getNodesNum(TreeNode* cur) {
        if (cur == NULL) return 0;
        int leftNum = getNodesNum(cur->left);
        int rightNum = getNodesNum(cur->right);
        int treeNum = leftNum + rightNum + 1;
        return treeNum;
    }
    int countNodes(TreeNode* root) {
        return getNodesNum(root);
    }
};

迭代法

/**
 * 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 countNodes(TreeNode* root) {
        queue<TreeNode*>  que;
        if (root != NULL) que.push(root);
        int result = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                result++;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

三、110. 平衡二叉树

110. 平衡二叉树

Note：递归左右中，因为是要判断高度。还有记得if判断

/**
 * 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 getHigh(TreeNode* node) {
        if (node == NULL) return 0;
        int leftHeight = getHigh(node->left);
        if (leftHeight == -1) return -1;
        int rightHight = getHigh(node->right);
        if (rightHight == -1) return -1;

        int result;

        if (abs(leftHeight - rightHight) > 1)
            result = -1;
        else
            result = 1 + max(leftHeight, rightHight);

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

四、257. 二叉树的所有路径

257. 二叉树的所有路径

Note：递归与回溯

/**
 * 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:
    void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {
        path.push_back(cur->val);
        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();
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        vector<int> path;
        if (root == NULL) return result;
        traversal(root, path, result);
        return result;
    }
};

五、404. 左叶子之和

404. 左叶子之和

Note：左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点

/**
 * 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 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 != NULL && root->left->left == NULL && root->left->right == NULL) {
            leftValue = root->left->val;
        }

        int rightValue = sumOfLeftLeaves(root->right);

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

六、513. 找树左下角的值

513. 找树左下角的值

Note：使用迭代法更容易

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

或者：
Note：使用迭代法来代替递归

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        stack<TreeNode*> st;
        st.push(root);

        while(!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);
            if (node->left) st.push(node->left);
            if (node->right) st.push(node->right);
        }
        return root;
    }
};

七、112. 路径总和

112. 路径总和

Note：仍然是递归的一天

/**
/**
 * 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:
    bool traversal(TreeNode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) return true;
        if (!cur->left && !cur->right) return false;

        if (cur->left) {
            count -= cur->left->val;
            if (traversal(cur->left, count)) return true;
            count += cur->left->val;
        }

        if (cur->right) {
            count -= cur->right->val;
            if (traversal(cur->right, count)) return true;
            count += cur->right->val;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL) return false;
        return traversal(root, targetSum - root->val);
    }
};

八、113. 路径总和 II

113. 路径总和 II

Note：跟112路径总和类似，需要加入vector

/**
 * 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 {
private:
    vector<vector<int>> result;
    vector<int> path;

    void traversal(TreeNode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) {
            result.push_back(path);
            return;
        }

        if (!cur->left && !cur->right) return;

        if (cur->left) {
            path.push_back(cur->left->val);
            count -= cur->left->val;
            traversal(cur->left, count);
            count += cur->left->val;
            path.pop_back();
        }

        if (cur->right) {
            path.push_back(cur->right->val);
            count -= cur->right->val;
            traversal(cur->right, count);
            count += cur->right->val;
            path.pop_back();
        }
        return;
    }
public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        result.clear();
        path.clear();
        if (root == NULL) return result;
        path.push_back(root->val);
        traversal(root, targetSum - root->val);
        return result;
    }
};

九、654. 最大二叉树

654. 最大二叉树

Note：递归，切割数组

/**
* 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:
  TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
      TreeNode* node = new TreeNode(0);

      if (nums.size() == 1) {
          node->val = nums[0];
          return node;
      }

      int maxValue = 0;
      int maxValueIndex = 0;

      for (int i = 0; i < nums.size(); i++) {
          if (nums[i] > maxValue) {
              maxValue = nums[i];
              maxValueIndex = i;
          }
      }
      node->val = maxValue;

      if (maxValueIndex > 0) {
          vector<int> newVec(nums.begin(), nums.begin() + maxValueIndex);
          node->left = constructMaximumBinaryTree(newVec);
      }

      if (maxValueIndex < (nums.size() - 1)) {
          vector<int> newVec(nums.begin() + maxValueIndex + 1, nums.end());
          node->right = constructMaximumBinaryTree(newVec);
      }
      return node;
  }
};

十、106. 从中序与后序遍历序列构造二叉树

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

Note：很容易写乱的一道题，回头再好好弄弄

/**
* 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 {
private:
  TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
      if (postorder.size() == 0) return NULL;

      int rootValue = postorder[postorder.size() - 1];
      TreeNode* root = new TreeNode(rootValue);

      if (postorder.size() == 1) return root;

      int delimiterIndex;
      for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
          if (inorder[delimiterIndex] == rootValue) break;
      }

      vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
      vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());

      postorder.resize(postorder.size() - 1);

      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;
  }
public:
  TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
      if (inorder.size() == 0 || postorder.size() == 0) return NULL;
      return traversal(inorder, postorder);
  }
};

总结

因为二叉树题比较多，就分上中下三篇记录了，对递归进行了更多次的练习，感觉更习惯递归算法，二叉树是很多算法的基础，非常重要！代码随想录一刷打卡——二叉树（中篇）