day28

【116/117 填充每个结点的下一个右侧结点指针】

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

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

• 思路 在基础层次遍历基础上 让元素出队并且左右孩子进队的时候 让该节点指向下一个结点即当前队头结点
• 运行成功 但遇到过几点bug 以后要规避
  • 最重要的一个是 注意变量是否还在其他地方被改值 上述代码中temp我一开始就是用的是size 但size会在if中被改值 可是size在for循环中也在使用 不希望被改值 因此我需要重新起一个变量名temp 否则fo循环执行次数就不够了
  • 另外 我没考虑当该层只有一个结点时 是无法取到node2会报错的 因此需要设置if条件
• 卡哥代码

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;

    }
};

• 哈哈我感觉我得代码还能少一两行^v

【104 二叉树的最大深度】

/**
 * 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:
    int maxDepth(TreeNode* root) {
        int result = 0;
        queue<TreeNode*> que;
        if (root != NULL)   que.push(root);
        int depth = 0;
        while(!que.empty()) {
            int size = que.size();  
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left)     que.push(node->left);
                if (node->right)    que.push(node->right);
            }
        }
        return depth;
    }
};

• 思路 在基本层次遍历代码基础上 只需要每次进入while即刚进入每一层时 depth++即可
• 一个常犯错误 TreeNode* node = que.front(); 要放在For循环内 放在外面只能取每层最左边的一个节点 无法取到该层其他结点

【111 二叉树的最小深度】

/**
 * 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:
    int minDepth(TreeNode* root) {
        int depth = 0;
        queue<TreeNode*> que;
        if (root != NULL)   que.push(root);
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                int flag = 0;
                if (node->left)  que.push(node->left);
                if (node->right) que.push(node->right);
                if (node->left == NULL && node->right == NULL) {
                    return depth;
                }                     
            }
        }
        return depth;
    }
};

• 思路一样 就是只需判断当没既没左又没右孩子的时候 就是最小深度