代码随想录算法训练营第十五天|层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树

于 2023-03-19 18:23:03 发布
阅读量67 收藏
点赞数
分类专栏： 代码随想录 文章标签： 算法 javascript 前端 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_60510462/article/details/129654161
版权

102.二叉树的层序遍历

题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/

/**
 * 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 queue=[],res=[]
queue.push(root)
if(root===null){
    return res
}
while(queue.length!==0){
// 记录当前层数元素的个数
let length=queue.length
// 存放每一个层的节点
let curNode=[]
for(let i=0;i<length;i++){
let node=queue.shift()
curNode.push(node.val)
// 存放当前层下一层的节点
node.left&&queue.push(node.left)
node.right&&queue.push(node.right)
}
// 把每一层的结果放入栈中
res.push(curNode)
}
return res
};

看完视频所学：

1.借助队列来进行层序遍历，通过保存每一层遍历过的元素。记录本层的元素的个数。

2.首先判断根节点是否为空，为空直接返回，不为空则记录当前层数元素的个数。并将其弹出存入，然后遍历弹出元素的左右子树，依次弹出直到队列中元素为空，循环结束。

107.二叉树的层序遍历Ⅱ

题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

/**
 * 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 levelOrderBottom = function(root) {
let res=[],queue=[]
queue.push(root)
while(queue.length&&root!==null){
    // 存放当前层数节点的数组
    let curNode=[]
    // 计算当前层数节点的数量
    let length=queue.length
    while(length--){
        let node=queue.shift()
        curNode.push(node.val)
        // 把下一层的左右子节点存入
        node.left&&queue.push(node.left)
        node.right&&queue.push(node.right)
    }
    res.unshift(curNode)
}
return res
};

看完视频题解所学：

1.此题和上一道题目的思路一样，不过返回的是自顶向上的顺序，只需要将前一个的结果翻转即可。

2.这里翻转运用了unshift()方法。unshift() 方法可向数组的开头添加一个或更多元素,并返回新的长度。避免最后翻转数组，减少时间。

199.二叉树的右视图：

题目链接:https://leetcode.cn/problems/binary-tree-right-side-view/

/**
 * 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 rightSideView = function(root) {
// 只需把每一层的最后节点返回即可
let res=[],queue=[]
queue.push(root)
while(queue.length&&root!==null){
    // 记录当前层的节点数
    let length=queue.length
    while(length--){
        let node=queue.shift()
        // length长度为0的时候表示遍历到了最后一个节点
        if(!length){
            res.push(node.val)
        }
        node.left&&queue.push(node.left)
        node.right&&queue.push(node.right)
    }
}
return res
};

题解思路：

1.本题实则的思路是将每一层的的最后节点返回即可

2.依旧是遍历，等每一层队列中的个数为0的时候，将其弹出放入要返回的结果中，则为所需要的每一层最后一个元素。

637.二叉树的层平均值：

题目链接：https://leetcode.cn/problems/average-of-levels-in-binary-tree/

/**
 * 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 averageOfLevels = function(root) {
let res=[],queue=[]
queue.push(root)
while(queue.length&&root!==null){
    // 每一层的节点个数
    let length=queue.length
    // sum 记录每一层的和
    let sum=0
    for(let i=0;i<length;i++){
        let node=queue.shift()
        sum+=node.val
        node.left&&queue.push(node.left)
        node.right&&queue.push(node.right)
    }
    // 每一层的平均值存入数组
    res.push(sum/length)
}
return res
};

解题思路：

1.依旧是深度遍历二叉树，只需要将每层的数相加除以本次的个数即可。

429.N叉树的层序遍历：

题目链接：https://leetcode.cn/problems/n-ary-tree-level-order-traversal/

/**
 * // Definition for a Node.
 * function Node(val,children) {
 *    this.val = val;
 *    this.children = children;
 * };
 */

/**
 * @param {Node|null} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
let res=[],queue=[]
queue.push(root)
while(queue.length&&root!==null){
    // 记录每一层节点的个数
let length=queue.length
// 存放每一层的节点个数
let curNode=[]
while(length--){
    let node=queue.shift()
    curNode.push(node.val)
    // 循环node的孩子
    for(let i of node.children){
       i&&queue.push(i)
    }
}
res.push(curNode)
}
return res
};

解题思路：

1.主要还是遍历然后将每一层输出。不同的一点是这次不是二叉树，而是N叉树，不能分左右孩子，而是得遍历父节点的孩子，然后加入队列最后输出即可。

515.在每个树行中找最大值：

题目链接：https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

/**
 * 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 largestValues = function(root) {
let res=[],queue=[]
queue.push(root)
while(queue.length&&root!==null){
    // 用来存放每一层的个数
    let length=queue.length
    // 设置初始最大值是队列的第一个元素
    let max=queue[0].val
    while(length--){
       let node=queue.shift()
       max=max>node.val?max:node.val
       node.left&&queue.push(node.left)
       node.right&&queue.push(node.right)
    }
    res.push(max)
}
return res
};

解题思路：

1.求每一层的最大值，本质依旧是深度遍历然后将每一个最大值表示出来。这里借助了设置最大值的初始值就是队列第一个值，将其与节点其他的值比较，哪一个大输出哪一个即可。

116.填充每个节点的下一个右侧节点指针

题目链接：https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/

/**
 * // Definition for a Node.
 * function Node(val, left, right, next) {
 *    this.val = val === undefined ? null : val;
 *    this.left = left === undefined ? null : left;
 *    this.right = right === undefined ? null : right;
 *    this.next = next === undefined ? null : next;
 * };
 */

/**
 * @param {Node} root
 * @return {Node}
 */
var connect = function(root) {
   if(root===null) return root
   let queue=[root]
    while(queue.length&&root!==null){
        // 记录每一层的节点个数
        let length=queue.length
        for(let i=0;i<length;i++){
            let node=queue.shift()
            //表示将这一层的元素连接起来
            if(i<length-1){
                node.next=queue[0]
            }
            node.left&&queue.push(node.left)
            node.right&&queue.push(node.right)
        }
    }
    return root
};

解题思路：

1.依旧采用遍历的思想，遍历每一层元素，然后取出每一层的第一个元素依次连接本层剩下的元素即可。

117.填充每一个节点的下一个右侧节点指针Ⅱ

题目链接：https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/

/**
 * // Definition for a Node.
 * function Node(val, left, right, next) {
 *    this.val = val === undefined ? null : val;
 *    this.left = left === undefined ? null : left;
 *    this.right = right === undefined ? null : right;
 *    this.next = next === undefined ? null : next;
 * };
 */

/**
 * @param {Node} root
 * @return {Node}
 */
var connect = function(root) {
    if(root===null) return null
    let queue=[root]
    while(queue.length>0){
        // 记录每一层的个数
        let length=queue.length
        for(let i=0;i<length;i++){
            let node=queue.shift()
            if(i<length-1) node.next=queue[0]
            node.left&&queue.push(node.left)
            node.right&&queue.push(node.right)
        }
    }
    return root
};

题解思路：

本题和上一题代码一模一样，只不过题目一个是给定一个二叉树，一个是给定一个完美二叉树。

104.二叉树的最大深度：

题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/

/**
 * 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 maxDepth = function(root) {
if(root===null) return null
let queue=[root]
let height=0
while(queue.length){
    // 遍历每一层的节点数
    let length=queue.length
    height++
    for(let i=0;i<length;i++){
        let node=queue.shift()
        node.left&&queue.push(node.left)
        node.right&&queue.push(node.right)
    }
}
return height
};

解题思路：

1.本题主要要求的是找出二叉树的最大深度，深度实则就是有几层。只需要在遍历每一层的时候让层数加1即可。

111.二叉树的最小深度

题目链接:https://leetcode.cn/problems/minimum-depth-of-binary-tree/

/**
 * 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 minDepth = function(root) {
if(root===null) return null
let queue=[root]
let depth=0
while(queue.length){
    // 遍历每一层的节点数
    let length=queue.length
    depth++
    for(let i=0;i<length;i++){
    let node=queue.shift()
    // 若左右节点都是null，则该节点深度最小
    if(node.left===null&&node.right===null){
        return depth
    }
    node.left&&queue.push(node.left)
    node.right&&queue.push(node.right)
    }
}
return depth
};

解题思路：

1.本题是求最小深度，最小深度是指只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点。

2.剩下的步骤就是遍历每一层，找出首次遇到的左右节点都是null，返回深度即可。

226.翻转二叉树

题目链接：https://leetcode.cn/problems/invert-binary-tree/

/**
 * 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) {
if(!root) return null
// 交换左右节点 先交换左右子树 再交换左右子树的节点
let left=invertTree(root.left)
let right=invertTree(root.right)
root.left=right
root.right=left
return root
};

解题思路：

1.主要就是将左子树与右子树进行交换即可。采用线序遍历的方法。

101.对称二叉树

题目链接：https://leetcode.cn/problems/symmetric-tree/

/**
 * 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) {
    //确定递归参数
const compareNode=function(left,right){
    //确定终止条件
    if(left===null&&right!==null||left!==null&&right===null){
         return false
    }else if(left===null&&right===null){
        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===null){
    return true
}
return compareNode(root.left,root.right)
};

解题思路：

1.主要在于比较根节点的左右子树是否相等，拆分开来比较左右子树的左右孩子节点是否相等，分为内侧和外侧依次比较即可。采用后序遍历。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值