算法Ⅰ（二叉树篇）

定义

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

二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

//递归
  int maxDepth(TreeNode *root) {
    return root == nullptr
               ? 0
               : max(maxDepth(root->left), maxDepth(root->right)) + 1;
  }

//BFS
  int maxDepth(TreeNode *root) {
    if (root == nullptr) return 0;
    int depth = 0;
    queue<TreeNode *> q;
    q.push(root);
    while (!q.empty()) {
      int size = q.size();//统计每一层的结点个数
      while (size-- > 0) {
        TreeNode *p = q.front();
        q.pop();
        if (p->left != nullptr) q.push(p->left);
        if (p->right != nullptr) q.push(p->right);
      }
      depth++;
    }
    return depth;
  }

验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

//判断中序遍历升序即可
bool isValidBST(TreeNode *root) {
    vector<int> v = inOrder(root);
    for (int i = 0; i < v.size() - 1; i++) {
      if (v[i + 1] <= v[i]) return false;
    }
    return true;
  }

  vector<int> inOrder(TreeNode *root) {
    vector<int> v;
    stack<TreeNode *> st;
    while (root || !st.empty()) {
      while (root) {
        st.push(root);
        root = root->left;
      }
      if (!st.empty()) {
        root = st.top();
        st.pop();
        v.push_back(root->val);
        root = root->right;
      }
    }
    return v;
  }

对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

//递归
  bool isSymmetric(TreeNode *root) {
    if (root == NULL) return true;
    return isSym(root->left, root->right);
  }
  bool isSym(TreeNode *left, TreeNode *right) {
    if (left == NULL && right == NULL) return true;
    if (left == NULL || right == NULL || left->val != right->val) return false;

    return isSym(left->left, right->right) && isSym(left->right, right->left);
  }

//迭代
  bool isSymmetric2(TreeNode *root) {
    queue<TreeNode *> q;
    if (root == NULL) return true;
    q.push(root->left);
    q.push(root->right);

    while (!q.empty()) {
      TreeNode *left = q.front();
      q.pop();
      TreeNode *right = q.front();
      q.pop();

      if (left == NULL && right == NULL) continue;
      if (left == NULL ^ right == NULL) return false;
      if (left->val != right->val) return false;

      q.push(left->left);
      q.push(right->right);
      q.push(left->right);
      q.push(right->left);
    }
    return true;
  }

二叉树的层序遍历

你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

class Solution {
 public:
  vector<vector<int>> levelOrder(TreeNode *root) {
    if (!root) return {};
    vector<vector<int>> res;
    queue<TreeNode *> q;
    q.push(root);

    while (!q.empty()) {
      int num = q.size();
      vector<int> v;
      for (int i = 0; i < num; i++) {
        TreeNode *tmp = q.front();
        q.pop();
        v.push_back(tmp->val);
        if (tmp->left) q.push(tmp->left);
        if (tmp->right) q.push(tmp->right);
      }
      res.push_back(v);
    }
    return res;
  }
};

108. 将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

//每次选取中间元素，二分递归
class Solution {
 public:
  TreeNode *sortedArrayToBST(vector<int> &nums) {
    if (nums.size() == 0) return nullptr;
    return func(nums, 0, nums.size() - 1);
  }

  TreeNode *func(vector<int> &nums, int start, int end) {
    if (start > end) return nullptr;
    int mid = (start + end) / 2;
    TreeNode *root = new TreeNode(nums[mid]);
    root->left = func(nums, start, mid - 1);
    root->right = func(nums, mid + 1, end);
    return root;
  }
};