【算法】代码随想录训练营Day14打卡，leetcode 102.层序遍历 101.对称二叉树 226.翻转二叉树

102.层序遍历

力扣链接:https://leetcode.cn/problems/binary-tree-level-order-traversal/description/

首先什么是层序遍历，其实就是我们所说的广度优先遍历。
那么我们可以使用一个队列，从头节点开始，出列一个节点，就把他的左右子节点给入列。
如图

解法

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
    let res = [];
    if(root == null) return res;
    const queue = [];
    queue.push(root);
    while(queue.length){
        let len = queue.length;
        let cur = [];
        for(let i=0;i<len;i++){
            let node = queue.shift()
            cur.push(node.val);
            if(node.left) queue.push(node.left);
            if(node.right) queue.push(node.right);
        }
        res.push(cur)
    }
    return res;
};

翻转二叉树

力扣链接:https://leetcode.cn/problems/invert-binary-tree/description/

这道题我们其实用深度优先遍历中的先序遍历或者是后序遍历
用广度优先遍历中的层序遍历都可以实现
就是在遍历的时候把每个节点的左右子节点交换一下

解法

层序遍历

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var invertTree = function(root) {

    const invertNode = function(root,left,right){
        let temp = left;
        left = right;
        right = temp;
        root.left = left;
        root.right = right
    }

    let queue = [];
    if(root == null) return root;
    queue.push(root);
    while(queue.length){
        let len = queue.length;
        for(let i=0;i<len;i++){
            let node = queue.shift();
            invertNode(node,node.left,node.right);
            if(node.left) queue.push(node.left);
            if(node.right) queue.push(node.right)
        }
    }
    return root
};

前序遍历
我们使用一个栈，通过 前序遍历的倒叙 右左中压入栈，然后再压入一个null 通过null来让每一个节点的左右子节点交换处理

	/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var invertTree = function(root) {

   const invertNode = function(root, left, right) {
        let temp = left;
        left = right;
        right = temp;
        root.left = left;
        root.right = right;
    }
    //使用迭代方法的前序遍历 
    let stack = [];
    if(root === null) {
        return root;
    }
    stack.push(root);
    while(stack.length){
        let node = stack.pop();
        if(node !== null) {
            //前序遍历顺序中左右  入栈顺序是前序遍历的倒序右左中
            node.right && stack.push(node.right);
            node.left && stack.push(node.left);
            stack.push(node);
            // push一个null 是为了每一个节点在最后都要先反转处理一下
            stack.push(null);
        } else {
            node = stack.pop();
            //节点处理逻辑
            invertNode(node, node.left, node.right);
        }
    }
};

101. 对称二叉树

力扣链接：https://leetcode.cn/problems/symmetric-tree/description/
使用两个指针 判断树的左右两树是否相等

题解

迭代法-队列
栈与队列的解法思路是一致的，只是在先弹出的是右节点这里要不同

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isSymmetric = function(root) {
    let queue = []
    if(root == null) return true;

    queue.push(root.left);
    queue.push(root.right);

    while(queue.length){
        let leftNode = queue.shift();
        let rightNode = queue.shift();
        if(leftNode == null && rightNode == null){
            continue
        }
        if(leftNode == null || rightNode == null || leftNode.val !== rightNode.val){
            return false;
        }
        queue.push(leftNode.left);
        queue.push(rightNode.right);
        queue.push(leftNode.right);
        queue.push(rightNode.left);
    } 
    return true;
};