day 15|二叉树|leetcode|C++|107. 二叉树的层序遍历 II|Leetcode 199. 二叉树的右视图| 226. 翻转二叉树

二叉树

理论基础

1. 迭代法中，由于栈具有存储特性，所以压在栈底的根节点右孩子长串在经历一段时间后还是会被调用。（递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。）

2. 层序遍历：

   逐层遍历，需要借助队列实现

   思路如下：

   • 建造队列，先把根节点压入队列
   • 建造res数组（vector<vector<int>>类型）
   • 当队列不为空，确定当前树行的节点个数（也就是本轮开始时队列中数的个数），方便后边进行for循环，for循环的作用是将当前行所有节点存入一个临时数组并将下一行的节点压入队列
   • 返回临时一维数组给res
   • 直到大循环中发生队列为空，出循环，返回res

   完整C++代码如下：

   /**
    * 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:
       vector<vector<int>> levelOrder(TreeNode* root) {
           queue<TreeNode*> que;
           vector<vector<int>> res;
           if (root)
               que.push(root);
           while (!que.empty()) {
               vector<int> vec;
               int size = que.size();
               for (int i = 0; i < size; i++) {
                   TreeNode* cur = que.front();
                   que.pop();
                   vec.push_back(cur->val);
                   if (cur->left)
                       que.push(cur->left);
                   if (cur->right)
                       que.push(cur->right);
               }
               res.push_back(vec);
           }
           return res;
       }
   };
   

   ---

Leetcode 107. 二叉树的层序遍历 II

链接：107. 二叉树的层序遍历 II

thought：层序遍历之后多了一个swap循环进行逆序重排，仅此而已。

完整C++代码如下：

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res_;
        if (root)
            que.push(root);
        while (!que.empty()) {
            vector<int> vec;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* cur = que.front();
                que.pop();
                vec.push_back(cur->val);
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
            res_.push_back(vec);
        }
       for(int i=0;i<res_.size()/2;i++){
           swap(res_[i],res_[res_.size()-1-i]);
       }
       return res_;
    }
};

---

Leetcode 199. 二叉树的右视图

链接：199. 二叉树的右视图

thought：层序遍历时每层记录最后一个节点，同时不用再设临时数组vec存储每行的所有节点。

完整C++代码如下：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if (root)
            que.push(root);
        while (!que.empty()) {
            int size = que.size();
            TreeNode* _back = que.back();
            res.push_back(_back->val);
            for (int i = 0; i < size; i++) {
                TreeNode* cur = que.front();
                que.pop();
                if (cur->left)
                    que.push(cur->left);
                if (cur->right)
                    que.push(cur->right);
            }
        }
        return res;
    }
};

---

Leetcode 226. 翻转二叉树

链接：226. 翻转二叉树

thought：

• 递归的使用

完整C++代码如下：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(!root)return NULL;
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

---

Leetcode 101. 对称二叉树

链接：101. 对称二叉树

• 递归的使用

完整C++代码如下：

class Solution {
public:
    bool isifSymmetric(TreeNode* left, TreeNode* right) {
        if (left == NULL & right != NULL)
            return false;
        else if (left != NULL & right == NULL)
            return false;
        else if (left == NULL && right == NULL)
            return true;
        else if (left->val != right->val)
            return false;
        bool outside = isifSymmetric(left->left, right->right);
        bool inside = isifSymmetric(left->right, right->left);
        bool result = outside & inside;
        return result;
    }
    bool isSymmetric(TreeNode* root) {
        return isifSymmetric(root->left, root->right);
    }
};