day15 - 层序遍历，反转二叉树，对称二叉树

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入： root = [3,9,20,null,null,15,7]
输出： [[3],[9,20],[15,7]]

var levelOrder = function(root) {
    if(!root) return []
    let stack = [root]
    let res = []
    let len = stack.length
    while(stack.length){
        let curLevel = []
        while(len --){
            let node = stack.shift()
            curLevel.push(node.val)
            node.left && stack.push(node.left)
            node.right && stack.push(node.right)
        }
        res.push(curLevel)
        len = stack.length
    }
    return res
};

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入： root = [4,2,7,1,3,6,9]
输出： [4,7,2,9,6,3,1]

var invertTree = function(root) {
    if(!root) return null
    if(!root.left && !root.right) return root
    let left = root.left
    root.left = invertTree(root.right)
    root.right = invertTree(left)
    return root
};

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) return null
    queue.push(root)
    while(queue.length){
        let len = queue.length
        while(len --){
            let node = queue.shift()
            invertNode(node,node.left,node.right)
            node.left && queue.push(node.left)
            node.right && queue.push(node.right)
        }
    }
    return root
};

101. 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入： root = [1,2,2,3,4,4,3]
输出： true

//递归
var isSymmetric = function(root) {
    const compareNode = function(left,right){
        if( left && !right ||right &&!left){
            return false
        }else if( !left && !right){
            return true
        }else if(left.val !== right.val){
            return false
        }

        let outside = compareNode(left.left,right.right)
        let inside = compareNode(left.right,right.left)

        return outside && inside
    }

    if(!root) return true
    return compareNode(root.left,root.right)
};

//迭代
var isSymmetric = function(root) {
    if(!root) return true

    let queue = []
    queue.push(root.left)
    queue.push(root.right)

    while(queue.length){
        let left  = queue.shift()
        let right = queue.shift()

        if(!left && !right){
            continue
        }

        if(!left && right || left &&!right || left.val !== right.val){
            return false
        }

        queue.push(left.left)
        queue.push(right.right)
        queue.push(left.right)
        queue.push(right.left)
    }
    return true
};