Day13 二叉树专项 — 层序遍历、翻转、对称

LeetCode 102. 二叉树的层序遍历

解题思路：利用队列

// 常规解法  
  vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> ret;
    queue<TreeNode*> node_q;

    if (root != nullptr) node_q.push(root);

    while (!node_q.empty()) {
      int size = node_q.size();
      vector<int> tmp_vec;

      for (int i = 0; i < size; i++) {
        TreeNode* node_ptr = node_q.front();
        tmp_vec.push_back(node_ptr->val);
        node_q.pop();

        if (node_ptr->left) node_q.push(node_ptr->left);
        if (node_ptr->right) node_q.push(node_ptr->right);
      }

      ret.push_back(tmp_vec);
    }

    return ret;
  }

// 递归解法
  void order(vector<vector<int>>& ret, TreeNode* cur, int depth) {
    if (cur == nullptr) return;
    
    if (ret.size() == depth) ret.push_back(vector<int>());
    ret[depth].push_back(cur->val);

    order(ret, cur->left, depth + 1);
    order(ret, cur->right, depth + 1);
  }

  vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> ret;
    int depth = 0;
    order(ret, root, depth);
    return ret;
  }

LeetCode 226. 翻转二叉树

解题思路：通过前、后、层次遍历逆转左右孩子

  // 递归
  void order(TreeNode* cur) {
    if (cur == nullptr) return;

    TreeNode* tmp = cur->left;
    cur->left = cur->right;
    cur->right = tmp;

    order(cur->left);
    order(cur->right);
  }

  TreeNode* invertTree(TreeNode* root) {
    order(root);
    return root;
  }


  // 迭代
  TreeNode* invertTree(TreeNode* root) {
    queue<TreeNode*> node_q;

    if (root != nullptr) node_q.push(root);

    while (!node_q.empty()) {
      int size = node_q.size();

      for (int i = 0; i < size; i++) {
        TreeNode* node_ptr = node_q.front();
        node_q.pop();

        TreeNode* tmp = node_ptr->left;
        node_ptr->left = node_ptr->right;
        node_ptr->right = tmp;

        if (node_ptr->left) node_q.push(node_ptr->left);
        if (node_ptr->right) node_q.push(node_ptr->right);
      }
    }

    return root;
  }

LeetCode 101. 对称二叉树

解题思路：左孩子的左节点与右孩子的右节点比较，左孩子的右节点与右孩子的左节点比较

  // 递归法
  bool compare(TreeNode* left, TreeNode* right) {
    if (left != nullptr && right != nullptr) {
      if (left->val != right->val) {
        return false;
      } else {
        return compare(left->left, right->right) &&
               compare(left->right, right->left);
      }
    } else if (left == nullptr && right == nullptr) {
      return true;
    } else {
      return false;
    }
  }

  bool isSymmetric(TreeNode* root) {
    if (root == nullptr) return true;
    return compare(root->left, root->right);
  }


  // 迭代法
  bool isSymmetric(TreeNode* root) {
    if (root == nullptr) return true;
    queue<TreeNode*> node_q;
    node_q.push(root->left);
    node_q.push(root->right);

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

      if (left && right) {
        if (left->val != right->val) {
          return false;
        } else {
          node_q.push(left->left);
          node_q.push(right->right);
          node_q.push(left->right);
          node_q.push(right->left);
        }
      } else if (!left && !right) {
        continue;
      } else {
        return false;
      }
    }
    return true;
  }