<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[keyil的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/keyil</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; keyil]]></copyright><item><title><![CDATA[LeetCode第十八题：104. 二叉树的最大深度（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106644732</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106644732</guid><author>keyil</author><pubDate>Tue, 09 Jun 2020 16:15:18 +0800</pubDate><description><![CDATA[给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。

解题思路：递归实现
代码如下：
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int v]]></description><category></category></item><item><title><![CDATA[LeetCode第十七题：100. 相同的树（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106623688</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106623688</guid><author>keyil</author><pubDate>Mon, 08 Jun 2020 16:56:37 +0800</pubDate><description><![CDATA[给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:       1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

输出: true
示例 2:

输入:      1          1
          /           \
         2             2

]]></description><category></category></item><item><title><![CDATA[LeetCode第十六题：94. 二叉树的中序遍历（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106607299</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106607299</guid><author>keyil</author><pubDate>Sun, 07 Jun 2020 21:00:54 +0800</pubDate><description><![CDATA[给定一个二叉树，返回它的中序遍历。

示例:

输入: [1,null,2,3]
   1
    \
     2
    /
   3

输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

解题思路：看见树就想到首先考虑递归，题目说递归很简单，进阶用迭代，目前先写个递归，还达不到进阶hhhh。
代码如下：
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *]]></description><category></category></item><item><title><![CDATA[LeetCode第十五题：2. 两数相加（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106589698</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106589698</guid><author>keyil</author><pubDate>Sat, 06 Jun 2020 16:43:16 +0800</pubDate><description><![CDATA[给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4)
输出：7 -&gt; 0 -&gt; 8
原因：342 + 465 = 807

解题思路：
1，遍历链表，将每两个结点的值相加，并存储到新链]]></description><category></category></item><item><title><![CDATA[LeetCode第十四题：238. 除自身以外数组的乘积（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106558749</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106558749</guid><author>keyil</author><pubDate>Thu, 04 Jun 2020 21:40:32 +0800</pubDate><description><![CDATA[给你一个长度为 n 的整数数组 nums，其中 n &gt; 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

 

示例:

输入: [1,2,3,4]
输出: [24,12,8,6]
 

提示：题目数据保证数组之中任意元素的全部前缀元素和后缀（甚至是整个数组）的乘积都在 32 位整数范围内。

说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。

进阶：
你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分]]></description><category></category></item><item><title><![CDATA[LeetCode第十三题：141. 环形链表（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106534985</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106534985</guid><author>keyil</author><pubDate>Wed, 03 Jun 2020 22:57:39 +0800</pubDate><description><![CDATA[给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：.]]></description><category></category></item><item><title><![CDATA[LeetCode第十二题：83. 删除排序链表中的重复元素（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106507426</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106507426</guid><author>keyil</author><pubDate>Tue, 02 Jun 2020 23:09:11 +0800</pubDate><description><![CDATA[给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1-&gt;1-&gt;2
输出: 1-&gt;2
示例 2:

输入: 1-&gt;1-&gt;2-&gt;3-&gt;3
输出: 1-&gt;2-&gt;3


解题思路：
比较当前结点的值与下一结点的值，
如果相等，删除该结点；
如果不相等，将指针指向下一结点。
代码如下：
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *]]></description><category></category></item><item><title><![CDATA[LeetCode第十一题：21. 合并两个有序链表（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106488917</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106488917</guid><author>keyil</author><pubDate>Tue, 02 Jun 2020 09:33:36 +0800</pubDate><description><![CDATA[将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例：

输入：1-&gt;2-&gt;4, 1-&gt;3-&gt;4
输出：1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4

解题思路：
1，设置一个前驱节点prev跟随遍历，设置一个前头结点prehead以便最后返回新链表。
2，循环判断l1.val与l2.val的大小，如果l1.val &lt;= l2.val，那么prev.next = l1，l1 = l1.next。
3，将prev]]></description><category></category></item><item><title><![CDATA[LeetCode第十题：1431. 拥有最多糖果的孩子（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106479772</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106479772</guid><author>keyil</author><pubDate>Mon, 01 Jun 2020 19:02:45 +0800</pubDate><description><![CDATA[给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。

对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。

示例 1：

输入：candies = [2,3,5,1,3], extraCandies = 3
输出：[true,true,true,false,true] 
解释：
孩子 1 有 2 个糖果，如果他]]></description><category></category></item><item><title><![CDATA[LeetCode第九题：101. 对称二叉树（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106463312</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106463312</guid><author>keyil</author><pubDate>Sun, 31 May 2020 23:08:26 +0800</pubDate><description><![CDATA[给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3
 

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3
 

进阶：

你可以运用递归和迭代两种方法解决这个问题吗？



解题思路：递归遍历二叉树，设置两个指针p,q分别遍历左子树和右子树。
代码如下：
/**
 *]]></description><category></category></item><item><title><![CDATA[LeetCode第八题：27. 移除元素（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106225174</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106225174</guid><author>keyil</author><pubDate>Tue, 19 May 2020 22:56:22 +0800</pubDate><description><![CDATA[给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,1,2,2,3,0,4,2.]]></description><category></category></item><item><title><![CDATA[LeetCode第七题：9. 回文数（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106173457</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106173457</guid><author>keyil</author><pubDate>Sun, 17 May 2020 13:46:06 +0800</pubDate><description><![CDATA[判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
进阶:
你能不将整数转为字符串来解决这个问题吗？

解题思路：转化为字符串来处理很简单，但是额外空间会用到很多，在此使用不转换.]]></description><category></category></item><item><title><![CDATA[LeetCode第六题：26. 删除排序数组中的重复项（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106160682</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106160682</guid><author>keyil</author><pubDate>Sat, 16 May 2020 16:13:58 +0800</pubDate><description><![CDATA[给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums .]]></description><category></category></item><item><title><![CDATA[LeetCode第五题：1299. 将每个元素替换为右侧最大元素（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106140311</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106140311</guid><author>keyil</author><pubDate>Fri, 15 May 2020 14:01:44 +0800</pubDate><description><![CDATA[给你一个数组 arr ，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用 -1 替换。
完成所有替换操作后，请你返回这个数组。
示例：
输入：arr = [17,18,5,4,6,1]
输出：[18,6,6,6,1,-1]
提示：
1 &lt;= arr.length &lt;= 10^4
1 &lt;= arr[i] &lt;= 10^5

解题思路：逆序遍历。
1，将原数组最后一个元素赋值给rightMax。rightMax = arr[length - 1]
2，然后将-1付给数组最后一.]]></description><category></category></item><item><title><![CDATA[LeetCode第四题：136. 只出现一次的数字（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106115055</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106115055</guid><author>keyil</author><pubDate>Thu, 14 May 2020 10:51:49 +0800</pubDate><description><![CDATA[给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4

解题思路：此题本人第一映像想到暴力破解hhhh，经过半分钟的思考过后想起了hashmap这个东东。但是题目要求不适用额外空间来实现，说明了hashmap行不通。最终在题解区找到了异或的方法（真TM巧妙）。
代码如下：
clas.]]></description><category></category></item><item><title><![CDATA[LeetCode第三题：237. 删除链表中的节点（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106107397</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106107397</guid><author>keyil</author><pubDate>Wed, 13 May 2020 21:51:15 +0800</pubDate><description><![CDATA[请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
现有一个链表 – head = [4,5,1,9]，它可以表示为:4—&gt;5—&gt;1—&gt;9
示例 1:
输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -&gt; 1 -&gt; 9.
示例 2:
输入: head = [4,5,1,9], node = 1
输出: [4,5,.]]></description><category></category></item><item><title><![CDATA[LeetCode第二题：7整数反转（java实现）]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106107125</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106107125</guid><author>keyil</author><pubDate>Wed, 13 May 2020 21:34:54 +0800</pubDate><description><![CDATA[给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
思路：
1，此题可以通过取余运算得到x的最后一位，然后再将x/10，循环。
2，重点在于判断反转后的数值是否溢出。
代码如下：
class So]]></description><category></category></item><item><title><![CDATA[Leetcode第一题：155最小栈(java实现)]]></title><link>https://blog.youkuaiyun.com/keyil/article/details/106086657</link><guid>https://blog.youkuaiyun.com/keyil/article/details/106086657</guid><author>keyil</author><pubDate>Tue, 12 May 2020 22:38:07 +0800</pubDate><description><![CDATA[设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
此题直接修改了底层的数据结构，用链表来模仿栈实现此题。
1，创建一个Node head;在节点中增加一个min区域，用于存放最小元素。
结构如：min-value-next。此时min和value相等。
2，在添加下一个Node n的时候，此时该Node的min]]></description><category></category></item></channel></rss>