代码随想录算法训练营第十五天 |

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

想法：每层都要进行遍历

/*
// 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*> myque;
        if(root!=NULL) {
            myque.push(root);
        }
        while(!myque.empty()) {
            int size = myque.size();
            Node* preNode;
            Node* node;

            for(int i=0; i<size; i++) {
                if(i==0) {
                    preNode = myque.front();
                    myque.pop();
                    node = preNode;
                }else {
                    node = myque.front();
                    myque.pop();
                    preNode->next = node;
                    preNode = preNode->next;
                }
                if(node->left) {
                    myque.push(node->left);
                }
                if(node->right) {
                    myque.push(node->right);
                }
            }
        }
        return root;
    }
};

226. 翻转二叉树 

/**
 * 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:
    void traversal(TreeNode* node) {
        if(node==nullptr) {
            return;
        }
        TreeNode* temp = node->left;
        node->left = node->right;
        node->right = temp;
        traversal(node->left);
        traversal(node->right);

    }

    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr) {
            return nullptr;
        }

        traversal(root);
        return root;
    }
};

101. 对称二叉树

想法：两两比较

/**
 * 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:
    bool isSys(TreeNode* node1, TreeNode* node2) {
        if(node1==nullptr && node2==nullptr) {
            return true;
        }
        if(node1==nullptr && node2!=nullptr) {
            return false;
        }
        if(node1!=nullptr && node2==nullptr) {
            return false;
        }
            return node1->val==node2->val && isSys(node1->left, node2->right) && 
            isSys(node1->right, node2->left);

    }

    bool isSymmetric(TreeNode* root) {
        if(root==nullptr) {
            return true;
        }
        return isSys(root->left, root->right);

    }
};

 100. 相同的树

/**
 * 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:
    bool traversal(TreeNode* node1, TreeNode* node2) {
        if(node1==nullptr && node2==nullptr) {
            return true;
        }
        if(node1==nullptr && node2!=nullptr) {
            return false;
        }
        if(node1!=nullptr && node2==nullptr) {
            return false;
        }
        return node1->val == node2->val && traversal(node1->left, node2->left) &&
                traversal(node1->right, node2->right);

    }

    bool isSameTree(TreeNode* p, TreeNode* q) {
        return traversal(p, q);

    }
};