代码随想录算法训练营D15

D14: 樱花真好看

层序遍历

vector<int> levelorderTraversal(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++) {
                TreeNode* node = que.front();
                que.pop();
                result.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }

102. Binary Tree Level Order Traversal

层序遍历的应用，直接修改一下，返回二维向量就行了

代码如下：

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> vec;
                int n=que.size();
                for(int i=0;i<n;i++){
                    TreeNode* node=que.front();
                    que.pop();
                    vec.push_back(node->val);
                    if(node->left) que.push(node->left);
                    if(node->right) que.push(node->right);
                }
                result.push_back(vec);
            }
        return result;
    }
};

107. Binary Tree Level Order Traversal II

这个相当于上面102最后结果反过来。一定要注意

int n=que.size();
for(int i=0;i<n;i++){

这里循环变量不能是que.size()，因为队列的大小在时刻变化

199. Binary Tree Right Side View

判断是否到了每一层的最后一个节点

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

637. Average of Levels in Binary Tree

这个就是每层计算一次平均值，代码略

429. N-ary Tree Level Order Traversal

N叉树，重点是N叉树的创建

代码如下

class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }
    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root)  {
        vector<vector<int>> r;
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int n=que.size();
            vector<int> vec;
            for(int i=0;i<n;i++){
                Node* node=que.front();
                que.pop();
                for(Node* no:node->children){
                    que.push(no);
                }
                    }
            r.push_back(vec);
        }
        return r;
    }
};

515. Find Largest Value in Each Tree Row

同理，层序遍历时记录每层最大值，代码略

116. Populating Next Right Pointers in Each Node

117. Populating Next Right Pointers in Each Node II

在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};

104. Maximum Depth of Binary Tree
遍历的层数就是二叉树的深度

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

111. Minimum Depth of Binary Tree

层序遍历，如果左右孩子都没有就代表到了最小深度

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

        return result;
    }
};

226. Invert Binary Tree
这个还是递归三部曲的问题
确定参数，确定终止条件，确定递归操作，代码如下

class Solution {
public:
    void invertChildren(TreeNode* root){
        if(root->left==NULL && root->right==NULL) return;
        else {
            TreeNode* tmp=root->left;
            root->left=root->right;
            root->right=tmp;
        }
        if(root->left) invertChildren(root->left);
        if(root->right) invertChildren(root->right);

    }
    
    TreeNode* invertTree(TreeNode* root) {
        if(root!=NULL) invertChildren(root);
        return root;
    }
};

101. Symmetric Tree

确定递归参数：左节点和右节点
确定终止条件：这个条件包括，左节点和右节点为空，以及左右节点的值
确定递归操作：二叉树的外圈和内圈
代码如下：

class Solution {
public:
    bool compare(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=compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        return outside&&inside;
    }
    
    
    bool isSymmetric(TreeNode* root) {
        if(root==NULL) return true;
        return compare(root->left, root->right);
    }
};