代码随想录第十五天|层序遍历与十道题、Leetcode 226.翻转二叉树、Leetcode 101. 对称二叉树

层序遍历

Leetcode 102. 二叉树的层序遍历

本质就是宽度优先搜索BFS，利用队列queue实现

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            vector<int> tempVec;
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* temp=que.front();
                que.pop();
                tempVec.push_back(temp->val);
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);  
            }
            result.push_back(tempVec);
        }
        return result;
    }
};

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

想了半天怎么从底开始遍历每一层，我寻思BFS也只能从上到下搜啊，结果答案是BFS然后把结果倒序，我服了。

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            vector<int> tempVec;
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* temp=que.front();
                que.pop();
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
                tempVec.push_back(temp->val);
            }
            result.push_back(tempVec);
        }
        reverse(result.begin(),result.end());//竟然是直接reverse，我真服了
        return result;
    }
};

Leetcode 199. 二叉树的右视图

和第一题基本是一样的方法，精髓在于每次循环一个size

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size=que.size();
            for(int i=0;i<size;i++){//留一个在里面最后pop
                TreeNode* temp=que.front();
                que.pop();
                if(i==size-1) result.push_back(temp->val);
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
        }
        return result;
    }
};

Leetcode 637.二叉树的层平均值

越来越熟练了，十分钟一道

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size=que.size();
            double sum=0;
            for(int i=0;i<size;i++){
                TreeNode* temp=que.front();
                que.pop();
                sum+=temp->val;
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
            result.push_back(sum/size);
        }
        return result;
    }
};

Leetcode 637.二叉树的层平均值

无他，唯手熟尔。

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int sizeQue=que.size();
            vector<int> vec;
            for(int i=0;i<sizeQue;i++){
                Node* temp=que.front();
                que.pop();
                vec.push_back(temp->val);
                int size=temp->children.size();
                for(int i=0;i<size;i++){
                    if(temp->children[i]) que.push(temp->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

Leetcode 515. 在每个树行中找最大值

一字过！

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size=que.size();
            int lineMax=-INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode* temp=que.front();
                que.pop();
                lineMax=max(lineMax,temp->val);
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
            result.push_back(lineMax);
        }
        return result;
    }
};

Leetcode 116.填充每个节点的下一个右侧节点指针

好好好，我逐渐理解了一切。

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size=que.size();
            for(int i=0;i<size;i++){
                Node* temp=que.front();
                que.pop();
                if(i!=size-1) temp->next=que.front();
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
        }
        return root;
    }
};

Leetcode 117.填充每个节点的下一个右侧节点指针II

？？？用上一个代码直接过了

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size=que.size();
            for(int i=0;i<size;i++){
                Node* temp=que.front();
                que.pop();
                if(i!=size-1) temp->next=que.front();
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
        }
        return root;
    }
};

Leetcode 104.二叉树的最大深度

竟然还可以用来数有多少层，因为层序遍历，每遍历一层记录一下就行

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int result=0;
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* temp=que.front();
                que.pop();
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
            result++;
        }
        return result;
    }
};

也可以用DFS，就是递归法，相对节省空间

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==NULL) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

Leetcode 111.二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        int result=0;
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            result++;
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* temp=que.front();
                que.pop();
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
                if(!temp->left && !temp->right) return result;
            }
        }
        return result;
    }
};

Leetcode 226.翻转二叉树

递归还是挺简单的

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

Leetcode 101. 对称二叉树

递归还要再练练，尤其是什么时候终止。

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