代码营打卡 Day15

1. 层序遍历(广度优先)

层序遍历二叉树就是按照层数遍历二叉树, 并且返回对应的值, 考虑借助队列完成这个问题

以这个二叉树为例, 首先把根节点6加入队列, 并且记录下队列的size1, 然后将6弹出, 将他的左右子节点4和7加入队列, 同时记录下队列的size为2(这意味着后面弹出两个元素记做第二层), 这里要注意需要用size = que.size()直接记录下, 而不能在后面的while中用while(que.size()--), 因为que.size在过程中不断变化

弹出4以后将4的左右子节点都加入队列中, 此时队列的元素是713, 但是由于size只减了一次, 所以还要弹出一次7, 并且将7的左右子节点58加入队列

伪代码如下

 

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; 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;
    }
};

python实现如下

import collections
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            level = []
            for i in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
        return result 

其中

queue = collections.deque([root])

的意思是使用collections.deque([root])是创建一个队列, 并将root作为初始元素放入队列中, 其中deque是一个双端队列, 支持在两端高效添加和删除元素

2. 翻转二叉树(226)

这里要注意是用的前序遍历还是后序遍历

做递归的时候要注意返回值、终止条件和执行操作

用递归的方法实现如下:

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

这里是中左右的顺序, 用的是前序, 如果改成左右中就是后序, 这道题用中序做比较麻烦, 因为中序时左中右的顺序, 一开始处理的是左子树, 交换以后的右边又是左子树, 会出现错误, 或者用中序遍历时两个都写成left, 但是比较容易混淆, 不推荐

或者用层序遍历的方式:

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root: 
            return None

        queue = collections.deque([root])    
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
        return root   

每一层的循环中执行左右互换的操作 

3. 对称二叉树

对称二叉树是要判断根节点的左右子树是否关于中轴对称, 首先传入的参数就是根节点的左右子节点, 然后考虑的是结束情况, 有以下几种情况:1. 左节点为空右节点不为空, 返回false 2. 左节点不为空右节点为空, 返回false, 3. 左节点右节点都为空, 返回true 4. 左节点右节点不为空但是值不相等, 返回false

如果不是这几种情况, 那么就是遍历下层, 看能否对称就是看左节点的右子树和右节点的左子树(内侧)以及左节点的左子树和右节点的右子树(外侧)是否相等, 如果两者最后都相等, 则返回true

这道题注意遍历顺序只能是后序遍历, 因为是左孩子和右孩子都处理完了, 才返回根节点, 所以是左右中或者右左中的遍历顺序

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        return self.compare(root.left, root.right)
    
    def compare(self, left, right):
        if left == None and right != None: return False
        elif left != None and right == None: return False
        elif left == None and right == None: return True
        elif left.val != right.val: return False
        #此时就是：左右节点都不为空，且数值相同的情况
        #此时才做递归，做下一层的判断
        outside = self.compare(left.left, right.right) 
        inside = self.compare(left.right, right.left) 
        isSame = outside and inside
        return isSame