代码随想录算法训练营第十四天 | 102.二叉树的层序遍历

102.二叉树的层序遍历

初见想法：使用队列

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> que;

        if (root == nullptr) return ans;
        que.push(root);

        while (!que.empty())
        {
            vector<int> temp;
            
            int sz = que.size();
            for (int i = 0; i < sz; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                
                temp.push_back(node->val);

                if (node->left != nullptr) que.push(node->left);
                if (node->right != nullptr) que.push(node->right);
            }

            ans.push_back(temp);
        }

        return ans; 
    }
};

使用队列遍历整个树，不一定要使用traversal()

107.二叉树的层次遍历II

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> que;

        if (root == nullptr) return ans;
        que.push(root);

        while (!que.empty())
        {
            int sz = que.size();
            vector<int> temp;
            for (int i = 0; i < sz; i++)
            {
            
                TreeNode* node = que.front();
                que.pop();
                temp.push_back(node->val);

                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }

            ans.push_back(temp);
        }

        reverse(ans.begin(), ans.end());
        return ans;
    }
};

大水题，和上一题的思路一摸一样，然后直接reverse即可

199.二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> ans;
        if (root == nullptr) return ans;
        
        queue<TreeNode*> que;
        que.push(root);

        while (!que.empty())
        {
            int sz = que.size();
            for (int i = 0; i < sz; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);

                if (i == sz-1) ans.push_back(node->val);
            }
        }

        return ans;
    }
};

637.二叉树的层平均值

想法：二叉树的层序遍历，秒杀

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> ans;
        if (root == nullptr) return ans;

        queue<TreeNode*> que;
        que.push(root);

        while (!que.empty())
        {
            int sz = que.size();
            double sum = 0;
            for (int i = 0; i < sz; i++)
            {
                TreeNode* node = que.front();
                que.pop();

                sum += node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }

            double avg = sum / sz;
            ans.push_back(avg); 
        }

        return ans;
    }
};

226. 翻转二叉树

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return nullptr;

        inverse(root->left, root->right);

        return root;
    }

    void inverse(TreeNode* leftNode, TreeNode* rightNode)
    {
        if (leftNode == nullptr && rightNode == nullptr) return;
        
        // 这种写法只在函数内交换了指针指向的地址，在函数内部是有效果的，不会被保留外面
        // 如果想通过指针swap，需要交换的是指针指针的地址的内容
        swap(*leftNode, *rightNode);

        if (leftNode) inverse(leftNode->left, leftNode->right);
        if (rightNode) inverse(rightNode->left, rightNode->right);
    }

};

上述错误写法，指针可能为空，所有不能通过 *node来取值

正确写法：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return nullptr;

        swap(root->left, root->right);

        if (root->left) invertTree(root->left);
        if (root->right) invertTree(root->right);

        return root;
    }
};

通过递归，不用再写一个function然后在function内部swap

101. 对称二叉树

class Solution {
public:
    bool isSymmetric(TreeNode* root) {

        return traversal(root->left, root->right);
    }

    bool traversal(TreeNode* leftnode, TreeNode* rightnode)
    {
        if (leftnode && rightnode)
        {
            if (leftnode->val == rightnode->val)
            {
                return traversal(leftnode->left, rightnode->right) && traversal(leftnode->right, rightnode->left);
            }
            else
            {
                return false;
            }
        }
        else if (!leftnode && !rightnode)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

};

笑死我了，这么写居然通过了，哈哈哈

主要思路就是左右各一个遍历，然后判断左右遍历到的值想不想等

官方答案：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {

        if (!root) return true;
        return traversal(root->left, root->right);
    }

    bool traversal(TreeNode* leftNode, TreeNode* rightNode)
    {
        if (!leftNode && !rightNode) return true;
        if (!leftNode || !rightNode) return false;
        return leftNode->val == rightNode->val && traversal(leftNode->right, rightNode->left) && traversal(leftNode->left, rightNode->right);   
    }
};

woc, 逻辑居然差不多