class Solution { public int minDepth(TreeNode root) { if (root == null) { return 0; } int depth = 0; Queue q = new LinkedList<>(); q.offer(root); while (!q.isEmpty()) { int sz = q.size(); depth++; for (int i = 0; i < sz; i++) { TreeNode cur = q.poll(); if (cur.left == null && cur.right == null) { return depth; } if (cur.left != null) { q.offer(cur.left); } if (cur.right != null) { q.offer(cur.right); } } } return depth; } }

• 思路：bfs，循环beginWord，对每个字符替换26个小写字符，看新生成的单词是否在wordList里面，如果存在就是一个合法的路径，直到新生成的单词是endWord，循环完成还是没到达endWord就返回0。双向bfs思路一样，只不过是从两边向中间靠拢，判断新生成的单词是否在另一个方向走过的路径中。

const ladderLength = (beginWord, endWord, wordList) => { const wordSet = new Set(wordList); const queue = []; queue.push([beginWord, 1]); //开始单词和层级加入队列while (queue.length) { const [word, level] = queue.shift()//出队 进行bfs if (word == endWord) {//和endword相等返回层级 return level; } for (let i = 0; i < word.length; i++) { //循环单词列表 for (let c = 97; c <= 122; c++) { //循环26个小写字符 //得到新的单词 const newWord = word.slice(0, i) + String.fromCharCode(c) + word.slice(i + 1); if (wordSet.has(newWord)) { //检查wordset包不包括新生成的单词 避重复入列 queue.push([newWord, level + 1]); //新单词加入队列 wordSet.delete(newWord); //避死循环 } } } } return 0; // bfs结束，始终没有遇到终点 };

var ladderLength = function(beginWord, endWord, wordList) { let wordSet = new Set(wordList) if (!wordSet.has(endWord)) return 0 //从beginWord到endWord let begSet = [] //从endWord到beginWord let endSet = [] begSet.push(beginWord) endSet.push(endWord)let n = 1//层级 while(begSet.length > 0){//开始遍历单词 const nextBegins = []//bfs下一层级的单词数组 //步数少数对换一下，让走的慢的在走几步 if(begSet.length > endSet.length){ let q = begSet begSet = endSet endSet = q } //循环begSet for(let k = 0; k < begSet.length; k++){ let m = begSet[k] for(let i = 0; i < m.length; i++){ for (let c = 97; c <= 122; c++){ //生成新词 let newm = m.slice(0, i) + String.fromCharCode(c) + m.slice(i + 1); if(endSet.includes(newm)){//相遇 return n + 1 } if( wordSet.has(newm)){ nextBegins.push(newm)//下一层bfs的单词数组 wordSet.delete(newm)//防止重复 } } } } begSet = nextBegins n++ //层级+1 } return 0};

• 思路：深度优先遍历，按根,左,右 返回字符串，方便反序列化的时候从根节点开始构建，递归左右子树，直到遇见了null节点。
• 复杂度：时间复杂度O(n)，每个节点访问一次，n是树的节点个数。空间复杂度O(n)，最坏情况下递归深度是n

const serialize = (root) => { if (root == null) {//遇到null 返回‘X’进行标示 return 'X'; } const left = serialize(root.left); //序列化左子树 const right = serialize(root.right); //序列化右子树 return root.val + ',' + left + ',' + right; //按根,左,右 返回字符串 }; const deserialize = (data) => { const list = data.split(','); //字符串转数组const buildTree = (list) => {//构建树 const rootVal = list.shift(); //第一个元素 if (rootVal == "X") {//如果是X，返回null return null; } const root = new TreeNode(rootVal); //如果不是X就创建节点 root.left = buildTree(list); //构建左子树 root.right = buildTree(list); //构建右子树 return root; //返回构建的节点 }; return buildTree(list); };

• 思路：广度优先遍历节点，不断子节点不断入队，按照根左右的顺序序列化和反序列化
• 复杂度：时间复杂度O(n)，每个节点访问一次，n是树的节点个数。空间复杂度O(n)，队列的空间

const serialize = (root) => { const queue = [root]; let res = []; while (queue.length) { const node = queue.shift(); //出队 if (node) {//node存在 推入根左右 res.push(node.val); queue.push(node.left); queue.push(node.right); } else {//如果不存在 推入‘x’ res.push('X'); } } return res.join(','); //数组转成字符串 }const deserialize = (data) => { if (data =https://www.it610.com/article/='X') return null; const list = data.split(','); //字符串转数组const root = new TreeNode(list[0]); //从队首开始构建 const queue = [root]; //根节点加入队列 let cursor = 1; //遍历到了第几个节点while (cursor < list.length) { //当队列没遍历完时 const node = queue.shift(); //出队const leftVal = list[cursor]; //左节点的值 const rightVal = list[cursor + 1]; //右节点的值if (leftVal != 'X') {//不是空节点 const leftNode = new TreeNode(leftVal); //构建左节点 node.left = leftNode; //左节点挂在父节点的left下 queue.push(leftNode); //自己入列 构建以自己为根的子树 } if (rightVal != 'X') { const rightNode = new TreeNode(rightVal); node.right = rightNode; queue.push(rightNode); } cursor += 2; //构建的节点数+2 } return root; //返回根 };

• 思路：递归左右子树，反转左右节点
• 复杂度：时间复杂度O(n)，树的每个节点都会遍历一遍。空间复杂度O(n)，递归栈空间，最坏的情况下，和节点的个数n相同

var invertTree = function(root) { if (root === null) {//递归终止条件 return null; } const left = invertTree(root.left); //递归左子树 const right = invertTree(root.right); //递归右子树 //交换左右节点 root.left = right; root.right = left; return root; };

class Solution { public TreeNode invertTree(TreeNode root) { if (root == null) { return null; } TreeNode left = invertTree(root.left); TreeNode right = invertTree(root.right); root.left = right; root.right = left; return root; } }

• 思路：递归比较左右子树
• 复杂度：时间复杂度O(n)，n是节点较少的树中的节点个数，递归有一个节点为null，另一个不为null就停止递归，空间复杂度O(n),递归深度不会超过节点个数

var isSameTree = function(p, q) { if(p == null && q == null) //都是null表示相同 return true; if(p == null || q == null) //只有一个是null表示不同 return false; if(p.val != q.val) //节点的值不同 return false; return isSameTree(p.left, q.left) && isSameTree(p.right, q.right); //递归左右子树 };

class Solution { public boolean isSameTree(TreeNode p, TreeNode q) { if(p == null && q == null) return true; if(p == null || q == null) return false; if(p.val != q.val) return false; return isSameTree(p.left, q.left) && isSameTree(p.right, q.right); } }

• 复杂度：时间复杂度O(n)，n是节点较少的树中的节点个数，空间复杂度O(n)，队列的空间不会超过节点较少的树中的节点个数

var isSameTree = function(p, q) { let pQ = [p], qQ = [q], res = truewhile (pQ.length) { pNode = pQ.shift() qNode = qQ.shift()if (pNode === null && qNode === null) { res = true } else if (pNode === null || qNode === null) { res = false break } else { if (pNode.val !== qNode.val) { res = false break } else { pQ.push(pNode.left) pQ.push(pNode.right)qQ.push(qNode.left) qQ.push(qNode.right) } } }return res };

class Solution { public boolean isSameTree(TreeNode p, TreeNode q) { Queue pQ = new LinkedList(); Queue qQ = new LinkedList(); pQ.offer(p); qQ.offer(q); boolean res = true; while (!pQ.isEmpty()) { TreeNode pNode = pQ.poll(); TreeNode qNode = qQ.poll(); if (pNode == null && qNode == null) { res = true; } else if (pNode == null || qNode == null) { res = false; break ; } else { if (pNode.val != qNode.val) { res = false; break ; } else { pQ.offer(pNode.left); pQ.offer(pNode.right); qQ.offer(qNode.left); qQ.offer(qNode.right); } } } return res; } }

• 复杂度：时间复杂度O(n)，每个节点遍历一次，空间复杂度O(n)，递归栈深度，最深不超过n

var isSymmetric = function(root) { if(!root) return true const isMirror = (l, r) => { if(!l && !r) return true; //两个空节点也为镜像 if( l && r && l.val === r.val &&//左节点和右节点相同，左子树和右子树也对称则返回true isMirror(l.left, r.right) && isMirror(l.right, r.left) ) { return true; } return false; } return isMirror(root.left, root.right) };

class Solution { public boolean isSymmetric(TreeNode root) { return isMirror(root, root); }public boolean isMirror(TreeNode l, TreeNode r) { if (l == null && r == null) { return true; } if (l == null || r == null) { return false; } return l.val == r.val && isMirror(l.left, r.right) && isMirror(l.right, r.left); } }

• 复杂度：时间复杂度O(n)，每个节点遍历一次，空间复杂度O(n)，队列的空间

function isSymmetric(root) { const isMirror = (l, r) => { const queue = [l, r]; while (queue.length) { const u = queue.shift(); const v = queue.shift(); if (!u && !v) continue; //两个空节点也为镜像 //左右节点只有一个节点为空，或者值不相同返回false if (!u || !v || u.val !== v.val) return false; queue.push(u.left, v.right); //加入左节点的左子树，右节点的右子树 queue.push(v.left, u.right); //加入右节点的左子树，左节点的右子树 } return true; }; return isMirror(root.left, root.right); }

class Solution { public boolean isSymmetric(TreeNode root) { return isMirror(root, root); }public boolean isMirror(TreeNode u, TreeNode v) { Queue queue = new LinkedList(); queue.offer(u); queue.offer(v); while (!queue.isEmpty()) { u = queue.poll(); v = queue.poll(); if (u == null && v == null) { continue; } if ((u == null || v == null) || (u.val != v.val)) { return false; }queue.offer(u.left); queue.offer(v.right); queue.offer(u.right); queue.offer(v.left); } return true; } }

• 思路：递归左右子树，不断让sum减去当前节点的值。左右子树有一个返回true就找到了一条这样的路径
• 复杂度：时间复杂度O(n)，n是节点个数，每个节点遍历一次。空间复杂度O(n)，取决于递归栈空间，最坏的情况下是O(n)

const hasPathSum = (root, sum) => { if (root == null) {//递归终止条件 return false; } if (root.left == null && root.right == null) {//遍历到叶子节点 return sum - root.val == 0; //sum正好减少到了0 返回ture 否则返回false } //递归左右子树，有一个返回true就找到了一条这样的路径 return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val); }

class Solution { public boolean hasPathSum(TreeNode root, int sum) { if (root == null) { return false; } if (root.left == null && root.right == null) { return sum == root.val; } return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val); } }

• 思路：递归左右子树，在递归的子阶段中，继续以该节点为根节点继续进行路径的寻找
• 复杂度：时间复杂度O(n^2)，所有节点都要遍历一边，还要寻找以该节点为根的子树中是否存在符合条件的路径。空间复杂度O(n)，递归空间

var pathSum = function(root, targetSum) { if (root == null) { return 0; }let ret = rootSum(root, targetSum); //以root为根节点的树中寻找路径 ret += pathSum(root.left, targetSum); //递归左子树，在左子树中寻找路径 ret += pathSum(root.right, targetSum); //递归右子树，在左子树中寻找路径 return ret; }; const rootSum = (root, targetSum) => { let ret = 0; if (root == null) { return 0; } const val = root.val; if (val === targetSum) { ret++; } //以root.left为根节点，targetSum - val为寻找的路径和，继续寻找路径 ret += rootSum(root.left, targetSum - val); //以root.right为根节点，targetSum - val为寻找的路径和，继续寻找路径 ret += rootSum(root.right, targetSum - val); return ret; }

class Solution { public int pathSum(TreeNode root, int targetSum) { if (root == null) { return 0; }int ret = rootSum(root, targetSum); ret += pathSum(root.left, targetSum); ret += pathSum(root.right, targetSum); return ret; }public int rootSum(TreeNode root, int targetSum) { int ret = 0; if (root == null) { return 0; } int val = root.val; if (val == targetSum) { ret++; } ret += rootSum(root.left, targetSum - val); ret += rootSum(root.right, targetSum - val); return ret; } }

• 思路：记录从根节点到该节点的路径和curr，在递归左右子树，看之前遍历过的路径中是否存在以curr - targetSum为 路径和的路径，如果存在，那么从根节点到当前节点的路径 减去 这条路径 就是符合条件的路径之一，看图
• 复杂度：时间复杂度O(n)，二叉树中的节点只遍历一遍。空间复杂度O(n)，递归栈深度。

var pathSum = function(root, targetSum) { const prefix = new Map(); //存放前缀和 和它的路径数量 prefix.set(0, 1); //初始化前缀和是0的个数 return dfs(root, prefix, 0, targetSum); }const dfs = (root, prefix, curr, targetSum) => {//curr指到达当前节点的路径上的和 if (root == null) {//空节点就没有路径了，返回0 return 0; }let ret = 0; curr += root.val; //加上当前节点ret = prefix.get(curr - targetSum) || 0; //获取以curr - targetSum的前缀和的数量 prefix.set(curr, (prefix.get(curr) || 0) + 1); //在prefix中增加curr的前缀和的数量 ret += dfs(root.left, prefix, curr, targetSum); //递归左子树 加上左子树前缀和为targetSum的路径数 ret += dfs(root.right, prefix, curr, targetSum); //递归右子树 加上右子树前缀和为targetSum的路径数 prefix.set(curr, (prefix.get(curr) || 0) - 1); //节点递归完毕，回溯curr的前缀和数量 避免重复计算return ret; }

class Solution { public int pathSum(TreeNode root, int targetSum) { HashMap prefix = new HashMap<>(); prefix.put(0L, 1); return dfs(root, prefix, 0, targetSum); }public int dfs(TreeNode root, Map prefix, long curr, int targetSum) { if (root == null) { return 0; }int ret = 0; curr += root.val; ret = prefix.getOrDefault(curr - targetSum, 0); prefix.put(curr, prefix.getOrDefault(curr, 0) + 1); ret += dfs(root.left, prefix, curr, targetSum); ret += dfs(root.right, prefix, curr, targetSum); prefix.put(curr, prefix.getOrDefault(curr, 0) - 1); return ret; } }

• 思路：递归左右子树，直到叶子节点，递归的过程中不断透传path，递归的每一层连接上当前节点的值
• 复杂度：时间复杂度O(n)，每个节点遍历一次。空间复杂度O(n)，递归栈空间

var binaryTreePaths = function(root) { const paths = []; const dfs = (root, path) => {//传入递归的节点和路径数组 if (root) { path += root.val.toString(); //加入当前节点 //叶子结点就将所有连接起来的节点字符串加入paths中 也就是其中一条路径 if (root.left === null && root.right === null) { paths.push(path); } else { path += "->"; //不是叶子节点继续递归左右子树 dfs(root.left, path); dfs(root.right, path); } } } dfs(root, ""); return paths; };

class Solution { public List binaryTreePaths(TreeNode root) { List paths = new ArrayList(); dfs(root, "", paths); return paths; }public void dfs(TreeNode root, String path, List paths) { if (root != null) { StringBuffer path1 = new StringBuffer(path); path1.append(Integer.toString(root.val)); if (root.left == null && root.right == null) { paths.add(path1.toString()); } else { path1.append("->"); dfs(root.left, path1.toString(), paths); dfs(root.right, path1.toString(), paths); } } } }

• 思路：用队列辅助进行广度优先遍历，不断将左右子节点加入队列，直到叶子节点
• 复杂度：同方法1

var binaryTreePaths = function(root) { const res = []; if (root === null) { return res; } const nodes = [root]; const paths = [root.val.toString()]; while (nodes.length) { const node = nodes.shift(); const path = paths.shift(); if (node.left === null && node.right === null) {//叶子节点 res.push(path); } else { if (node.left !== null) {//左节点不为空 加入队列 nodes.push(node.left); paths.push(path + "->" + node.left.val.toString()); }if (node.right !== null) {//右节点不为空 加入队列 nodes.push(node.right); paths.push(path + "->" + node.right.val.toString()); } } } return res; };

class Solution { public List binaryTreePaths(TreeNode root) { List res = new ArrayList(); if (root == null) { return res; } Queue nodeQueue = new LinkedList(); Queue pathQueue = new LinkedList(); nodeQueue.offer(root); pathQueue.offer(Integer.toString(root.val)); while (!nodeQueue.isEmpty()) { TreeNode node = nodeQueue.poll(); String path = pathQueue.poll(); if (node.left == null && node.right == null) { res.add(path); } else { if (node.left != null) { nodeQueue.offer(node.left); pathQueue.offer(new StringBuffer(path).append("->").append(node.left.val).toString()); }if (node.right != null) { nodeQueue.offer(node.right); pathQueue.offer(new StringBuffer(path).append("->").append(node.right.val).toString()); } } } return res; } }

• 思路：深度优先遍历，先递归右节点 让它在下一层先被处理，当res长度和step相等时 当前节点就是这一层的右节点，加入数组中
• 复杂度：时间复杂度O(n)，每个节点遍历一次。空间复杂度O(n)，递归栈空间

var rightSideView = function (root) { function dfs(root, step, res) {//传入根节点 层数 右视的节点的数组 if (root) { if (res.length === step) { res.push(root.val); //当res长度和step相等时 当前节点就是这一层的右节点 加入数组中 } dfs(root.right, step + 1, res); //先递归右节点 让它在下一层先被处理 dfs(root.left, step + 1, res); } } if (!root) return []; let arr = []; dfs(root, 0, arr); return arr; };

class Solution { List res; public List rightSideView(TreeNode root) { res = new LinkedList<>(); if (root == null) { return res; } dfs(root, 0); return res; }private void dfs(TreeNode root, int depth) { if (root == null) { return; } if (depth == res.size()) { res.add(root.val); } dfs(root.right, depth+1); dfs(root.left, depth+1); } }

• 思路：广度优先遍历，记录每一层的节点个数，出队之后让长度减1，当当前层长度等于1时 说明是最边的节点。
• 复杂度：时间复杂度O(n)，每个节点遍历一次。空间复杂度O(n)，队列的空间

var rightSideView = function (root) { if (!root) return []; let queue = [root]; //广度优先遍历的队列 首先加入root let arr = []; //存放右视的节点 while (queue.length > 0) { let len = queue.length; while (len) { let node = queue.shift(); //取出队列第一个元素 if (len === 1) arr.push(node.val); //当当前层长度等于1时 说明是最边的节点 if (node.left) queue.push(node.left); //继续向队列中添加左右节点 if (node.right) queue.push(node.right); len--; //出队之后 当前层长度减1 } } return arr; };

class Solution { public List rightSideView(TreeNode root) { List res = new LinkedList<>(); if (root == null) { return res; } Queue queue = new LinkedList<>(); queue.offer(root); while (!queue.isEmpty()) { int size = queue.size(); TreeNode curr = null; for (int i = 0; i < size; ++i) { curr = queue.poll(); if (curr.left != null) { queue.offer(curr.left); } if (curr.right != null) { queue.offer(curr.right); } } res.add(curr.val); //或者在换一种思路，循环完当前层之后，最后出队的就是当前层最右边的一个 } return res; } }

推荐阅读

• 

  凉拌鸡爪——促进骨骼预防高血压
• 

  写在静心手触上海课程前
• 

  2345智能浏览器怎么更改主页 2345智能浏览器主页如何更改
• 

  原来是这些原因 为什么有时候手机收不到验证码
• 

  吃荔枝上火吗？
• 

  西门子新款冰箱系列：科技与品质的好融合，让您的厨房更智能
• 

  再见2018，活出精彩2019
• 

  清明何止雨纷纷
• 

  JS|深拷贝浅拷贝的区别（如何实现一个深拷贝？）
• 

  excel2019怎么提供声音反馈
• 

  上夜班不可以吃芒果和火龙果 芒果不能和什么一起吃
• 

  如何设置新买的服务器的映射？ 新买的服务器怎么映射
• 

  图文 虞姬是自刎还是被人杀死的，揭秘虞姬死亡的真相
• 

  三国志战略版卧薪尝胆战法攻略 S级战法卧薪尝胆简评
• 

  机动车怎么审车 机动车怎么审
• 

  边 刑法关于放行偷越国境人员法定量刑档次是怎样
• 

  mongodb的坑 mongodb凉了吗
• 

  怎么蒸豆包蒸豆包的方法 如何蒸酥皮豆包，酥皮包子的做法窍门
• 

  2023年10月份重庆多雨吗
• 

  违章代码46131是什么意思

• PMSJ寻平面设计师之现代(Hyundai）
• 杜月笙的口才
• 画解算法（1.|画解算法：1. 两数之和）
• Guava|Guava RateLimiter与限流算法
• Linux下面如何查看tomcat已经使用多少线程
• 皮夹克
• 解读《摩根集团》（1）
• 绘本与写作
• 一个选择排序算法
• SG平滑轨迹算法的原理和实现