LeetCodeDay15 —— 对称二叉树&二叉树的层次遍历

101. 对称二叉树

描述
  • 给定一个二叉树,检查它是否是镜像对称的。
示例
二叉树 [1,2,2,3,4,4,3] 是对称的。
      1
    / \
    2   2
  / \ / \
  3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
      1
    / \
    2   2
    \   \
    3    3
说明
- 如果你可以运用递归和迭代两种方法解决这个问题,会很加分。
思路
  1. 类比两个相等的二叉树,两个树镜像对称,即左树的左子树和右树的右子树相等、左树的右子树和右树的左子树相等。
  2. 迭代版本,则利用一个栈来代替递归的作用。
    (参考地址)
class Solution_101_01 {
 public:
  bool isSymmetric(TreeNode* root) {
    if (root == NULL) return true;
    return isMirror(root->left, root->right);
  }
  bool isMirror(TreeNode* root1, TreeNode* root2) {
    // If both trees are emptu, then they are mirror images
    if (root1 == NULL && root2 == NULL) return true;

    // For two trees to be mirror images, the following three
    // conditions must be true
    // 1 - Their root node's key must be same
    // 2 - left subtree of left tree and right subtree
    //      of right tree have to be mirror images
    // 3 - right subtree of left tree and left subtree
    //      of right tree have to be mirror images
    if (root1 && root2 && root1->val == root2->val)
      return isMirror(root1->left, root2->right) &&
             isMirror(root1->right, root2->left);

    // if neither of above conditions is true then root1
    // and root2 are not mirror images
    return false;
  }
};

class Solution_101_02 {
 public:
  bool isSymmetric(TreeNode* root) {
    if (root == NULL) return true;
    return isMirror(root->left, root->right);
  }
  bool isMirror(TreeNode* root1, TreeNode* root2) {
    stack<TreeNode*> s;
    s.push(root1);
    s.push(root2);
    while (!s.empty()) {
      TreeNode* tmp1 = s.top();
      s.pop();
      TreeNode* tmp2 = s.top();
      s.pop();
      if (!tmp1 && !tmp2) continue;
      if (!tmp1 || !tmp2 || tmp1->val != tmp2->val) return false;
      s.push(tmp1->left);
      s.push(tmp2->right);
      s.push(tmp1->right);
      s.push(tmp2->left);
    }
    return true;
  }
};

102. 二叉树的层次遍历

描述
  • 给定一个二叉树,返回其按层次遍历的节点值。(即逐层地,从左到右访问所有节点)。
示例
给定二叉树: [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果:
[
  [3],
  [9,20],
  [15,7]
]
思路
  1. 利用队列实现层次遍历,两个队列交替使用,保存“层”的信息。
  2. 优化上述解法中利用两个队列来解决“层”的问题。每次遍历时,先取元素的个数,相当于是获得了改成元素的个数,再遍历。
class Solution_102_01 {
 public:
  vector<vector<int>> levelOrder(TreeNode* root) {
    if (root == NULL) return vector<vector<int>>();
    vector<vector<int>> res;
    queue<TreeNode*> q1, q2;
    q1.push(root);
    while (!q1.empty() && !q2.empty()) {
      queue<TreeNode*>& curQ = q1.empty() ? q2 : q1;
      queue<TreeNode*>& bakQ = curQ == q1 ? q2 : q1;
      vector<int> tmp;
      while (!curQ.empty()) {
        TreeNode* node = curQ.front();
        curQ.pop();
        tmp.push_back(node->val);
        if (node->left) bakQ.push(node->left);
        if (node->right) bakQ.push(node->right);
      }
      res.push_back(tmp);
    }
    return res;
  }
};

class Solution_102_02 {
 public:
  vector<vector<int>> levelOrder(TreeNode* root) {
    if(!root) return {};
    vector<vector<int>> res;
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty()){
      int size = q.size();
      vector<int> level;
      while(size--){
        TreeNode* node = q.front();
        q.pop();
        level.push_back(node->val);
        if(node->left) q.push(node->left);
        if(node->right) q.push(node->right);
      }
      res.push_back(level);
    }
    return res;
  }
};
    原文作者:GoMomi
    原文地址: https://www.jianshu.com/p/e3df4cc26c76
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞