随想录二刷Day16——二叉树

二叉树

5. 二叉树的层序遍历

102. 二叉树的层序遍历

思路：
每次将一层的所有节点推进队列，遍历该层所有节点值加入结果集的同时，将下一层入队。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if (root == NULL) return result;
        queue<TreeNode *> que;
        que.push(root);

        while (!que.empty()) {
            TreeNode *cur = NULL; 
            vector<int> vec;    
            int size = que.size();

            for (int i = 0; i < size; i++) {
                cur = que.front(); que.pop();
                vec.push_back(cur->val);
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
            result.push_back(vec);
        }

        return result;
    }
};

6. 翻转二叉树

226. 翻转二叉树

思路：
先序遍历二叉树，遇到非空节点，交换其左右子节点即可。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        TreeNode *cur = root;
        if (root == NULL) return NULL;
        preorder(root);

        return root;
    }

private:
    void preorder(TreeNode *root) {
        if (!root->left && !root->right) return ;
        if (root->left || root->right) swap(root->left, root->right);

        if (root->left) preorder(root->left);
        if (root->right) preorder(root->right);
    }
};

思路：
栈模拟递归，交换非空节点的左右子节点。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return NULL;
        stack<TreeNode *> stk;
        stk.push(root);

        while (!stk.empty()) {
            TreeNode *cur = stk.top(); stk.pop();
            swap(cur->left, cur->right);
            if (cur->left) stk.push(cur->left);
            if (cur->right) stk.push(cur->right);
        }

        return root;
    }
};

7. 对称二叉树

101. 对称二叉树

思路：
对称的遍历二叉树，左子树左侧节点与右子树右侧节点比较是否相等。

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

private:
    bool compare(TreeNode *leftNode, TreeNode *rightNode) {
        if (!leftNode && !rightNode) return true; // 左右都空
        else if (!leftNode && rightNode) return false; // 左空右不空
        else if (leftNode && !rightNode) return false; // 左不空右空
        else if (leftNode->val != rightNode->val) return false; // 左右都不空，但值不相等

        return compare(leftNode->left, rightNode->right) && compare(leftNode->right, rightNode->left);
    }
};

思路：
用队列实现

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode *> que;
        que.push(root->left);
        que.push(root->right);

        while (!que.empty()) {
            TreeNode *curL = que.front(); que.pop();
            TreeNode *curR = que.front(); que.pop();

            if (!curL && !curR) continue; // 左右都空
            else if (!curL && curR) return false; // 左空右不空
            else if (curL && !curR) return false; // 左不空右空
            else if (curL->val != curR->val) return false; // 左右都不空，但值不相等

            que.push(curL->left);
            que.push(curR->right);
            que.push(curL->right);
            que.push(curR->left);
        }

        return true;
    }
};