<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[LetJava的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/LetJava</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; LetJava]]></copyright><item><title><![CDATA[Leetcode  222. 完全二叉树的节点个数]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97811333</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97811333</guid><author>LetJava</author><pubDate>Tue, 30 Jul 2019 23:51:10 +0800</pubDate><description><![CDATA[题目
解答
解法一：全部遍历
代码
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class S...]]></description><category></category></item><item><title><![CDATA[Leetcode  199. 二叉树的右视图]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97695986</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97695986</guid><author>LetJava</author><pubDate>Mon, 29 Jul 2019 23:24:32 +0800</pubDate><description><![CDATA[题目
给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例:

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-right-side-view
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解答
解法一：递归 + dfs
深搜，优先搜索右子树。只将同一...]]></description><category></category></item><item><title><![CDATA[Leetcode  173. 二叉搜索树迭代器]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97662219</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97662219</guid><author>LetJava</author><pubDate>Mon, 29 Jul 2019 23:01:06 +0800</pubDate><description><![CDATA[题目
实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。
调用 next() 将返回二叉搜索树中的下一个最小的数。


BSTIterator iterator = new BSTIterator(root);
iterator.next();    // 返回 3
iterator.next();    // 返回 7
iterator.hasNext(); // 返回 true...]]></description><category></category></item><item><title><![CDATA[Leetcode  145. 二叉树的后序遍历]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97651387</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97651387</guid><author>LetJava</author><pubDate>Mon, 29 Jul 2019 17:17:49 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，返回它的 后序 遍历。

进阶: 递归算法很简单，你可以通过迭代算法完成吗？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解答
解法一：递归
递归解法不用多说，很简单。
代码
/**
...]]></description><category></category></item><item><title><![CDATA[Leetcode  144. 二叉树的前序遍历]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97620100</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97620100</guid><author>LetJava</author><pubDate>Sun, 28 Jul 2019 23:10:04 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，返回它的 前序 遍历。

进阶: 递归算法很简单，你可以通过迭代算法完成吗？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-preorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解答
解法一：递归
递归算法不用多说，很简单。
代码
/**
 ...]]></description><category></category></item><item><title><![CDATA[Leetcode  129. 求根到叶子节点数字之和]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97618370</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97618370</guid><author>LetJava</author><pubDate>Sun, 28 Jul 2019 19:50:49 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。
例如，从根到叶子节点路径 1-&gt;2-&gt;3 代表数字 123。
计算从根到叶子节点生成的所有数字之和。
说明: 叶子节点是指没有子节点的节点。


来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sum-root-to-leaf-...]]></description><category></category></item><item><title><![CDATA[Leetcode  124. 二叉树中的最大路径和]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97561937</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97561937</guid><author>LetJava</author><pubDate>Sat, 27 Jul 2019 22:10:06 +0800</pubDate><description><![CDATA[题目
给定一个非空二叉树，返回其最大路径和。
本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。


来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-maximum-path-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解答
递...]]></description><category></category></item><item><title><![CDATA[Leetcode  117. 填充每个节点的下一个右侧节点指针 II]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97534872</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97534872</guid><author>LetJava</author><pubDate>Sat, 27 Jul 2019 20:57:01 +0800</pubDate><description><![CDATA[题目
给定一个二叉树
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。

提示：

你只能使用常量级额外空间。
使用递归解题也符合要求，本题中...]]></description><category></category></item><item><title><![CDATA[Leetcode  116. 填充每个节点的下一个右侧节点指针]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97513230</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97513230</guid><author>LetJava</author><pubDate>Sat, 27 Jul 2019 15:10:21 +0800</pubDate><description><![CDATA[题目
给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL...]]></description><category></category></item><item><title><![CDATA[Leetcode  114. 二叉树展开为链表]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97441299</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97441299</guid><author>LetJava</author><pubDate>Sat, 27 Jul 2019 14:08:46 +0800</pubDate><description><![CDATA[题目
来自力扣：leetcode 
解答
解法一：
代码
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
...]]></description><category></category></item><item><title><![CDATA[Leetcode  113. 路径总和 II]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97422511</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97422511</guid><author>LetJava</author><pubDate>Fri, 26 Jul 2019 21:47:27 +0800</pubDate><description><![CDATA[题目
给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
说明: 叶子节点是指没有子节点的节点。

来自力扣：leetcode 113. 路径总和 II
解答
本题是 Leetcode 112. 路径总和 的变种题，只需要将走过的路径保存下来即可。
最简单的方法是 递归解法 。
递归步骤如下：

使用一个 cur 列表保存已经走过的路径，遍历完左右子树后再回退。
...]]></description><category></category></item><item><title><![CDATA[Leetcode  112. 路径总和]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97418110</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97418110</guid><author>LetJava</author><pubDate>Fri, 26 Jul 2019 21:29:02 +0800</pubDate><description><![CDATA[题目
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
说明: 叶子节点是指没有子节点的节点。

来自力扣：leetcode 112. 路径总和
解答
解法一：递归
按照前序遍历的顺序递归。
当到达叶子结点的时候，判断此时 sum 是否能被减成 0。
代码
/**
 * Definition for a binary tree node.
...]]></description><category></category></item><item><title><![CDATA[Leetcode  111. 二叉树的最小深度]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97414547</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97414547</guid><author>LetJava</author><pubDate>Fri, 26 Jul 2019 20:27:42 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。

解答
解法一：递归
具体如下：

如果当前结点为空，返回 0
如果左子树是空，返回右子树的最小深度 + 1
如果右子树是空，返回左子树的最小深度 + 1
如果左子树和右子树都不为空，返回二者最小的深度 + 1

代码
/**
 * Definition for...]]></description><category></category></item><item><title><![CDATA[Leetcode  110. 平衡二叉树]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97387244</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97387244</guid><author>LetJava</author><pubDate>Fri, 26 Jul 2019 14:47:36 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。



解答
解法一：多次遍历 O(n^2)
思路简单。
对于每一个结点都需要遍历一下左右子树，找到左右子树高度，然后判断是否符合平衡二叉树条件。
这导致时间复杂度变成 O(n^2) 。
代码
/**
 * Definition for a bin...]]></description><category></category></item><item><title><![CDATA[Leetcode  108. 将有序数组转换为二叉搜索树]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97375423</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97375423</guid><author>LetJava</author><pubDate>Fri, 26 Jul 2019 13:39:01 +0800</pubDate><description><![CDATA[题目
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

解答
解法一：递归
递归比较好理解。
步骤如下：

取区间的中点作为根节点。
构造左子树 。
构造右子树。

代码
/**
 * Definition for a binary tree node.
 * public class Tr...]]></description><category></category></item><item><title><![CDATA[Leetcode  107. 二叉树的层次遍历 II]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97311784</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97311784</guid><author>LetJava</author><pubDate>Thu, 25 Jul 2019 22:48:43 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

解答
解法一：递归
其实本题还是 Leetcode 102. 二叉树的层次遍历 的一个变种题。
对于二叉树层序遍历的结果反向一下就好了。。
二叉树的层次遍历：点这里
代码
/**
 * Definition for a binary tree node.
 * public cla...]]></description><category></category></item><item><title><![CDATA[Leetcode  104. 二叉树的最大深度]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97289627</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97289627</guid><author>LetJava</author><pubDate>Thu, 25 Jul 2019 19:33:44 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

解答
本题可以使用多种方式：

先序，中序，后序，层序等等的都行。
不论怎么实现遍历：递归，栈，Mirros 均可。
对于这些方式就不再多说了。

最简单的方式还是递归。
可以看出：

null 的深度是 0。
每个结点的最大深度 = max(左子树的最大深度...]]></description><category></category></item><item><title><![CDATA[Leetcode  103. 二叉树的锯齿形层次遍历]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97286054</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97286054</guid><author>LetJava</author><pubDate>Thu, 25 Jul 2019 19:19:49 +0800</pubDate><description><![CDATA[题目
解答
解法一：递归
前一道题目 Leetcode 102. 二叉树的层次遍历 的变种题。
递归方式只需要在原来的基础上增加一个奇偶层判断即可。
二叉树的层次遍历 博客地址：二叉树的层次遍历
代码
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNod...]]></description><category></category></item><item><title><![CDATA[Leetcode  102. 二叉树的层次遍历]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97282674</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97282674</guid><author>LetJava</author><pubDate>Thu, 25 Jul 2019 18:41:52 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

解答
解法一：递归
深度等价于层级， 可利用深度来判断当前结点所处的层级。
进而可以根据当前结点的深度定位其在 res 的下标位置。
代码
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
...]]></description><category></category></item><item><title><![CDATA[Leetcode  101. 对称二叉树]]></title><link>https://blog.youkuaiyun.com/LetJava/article/details/97279894</link><guid>https://blog.youkuaiyun.com/LetJava/article/details/97279894</guid><author>LetJava</author><pubDate>Thu, 25 Jul 2019 18:06:52 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

解答
解法一：递归
本题是 Leetcode 100. 相同的树 的变种题。
Leetcode 100. 相同的树 可看我上篇博客：上篇博客。
本题递归思路：

如果当前值不相等，结束。
否则因为为镜像树，所以需要递归 (...]]></description><category></category></item></channel></rss>