<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Cold__Winter的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/Cold__Winter</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; Cold__Winter]]></copyright><item><title><![CDATA[LeetCode 1089. 复写零 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/120559316</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/120559316</guid><author>Cold__Winter</author><pubDate>Thu, 30 Sep 2021 01:45:52 +0800</pubDate><description><![CDATA[题目
给你一个长度固定的整数数组 arr，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。
注意：请不要在超过该数组长度的位置写入元素。
要求：请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。

示例 1：
输入：[1,0,2,3,0,4,5,0]
输出：null
解释：调用函数后，输入的数组将被修改为：[1,0,0,2,3,0,0,4]


示例 2：
输入：[1,2,3]
输出：null
解释：调用函数后，输入的数组将被修改为：[1,2,3]


提示：
1 &lt;= arr]]></description><category></category></item><item><title><![CDATA[LeetCode 118. 杨辉三角 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/120492487</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/120492487</guid><author>Cold__Winter</author><pubDate>Sun, 26 Sep 2021 17:08:19 +0800</pubDate><description><![CDATA[题目描述
给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。

示例 1:
输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]


示例 2:
输入: numRows = 1
输出: [[1]]

提示:

1 &lt;= numRows &lt;= 30

思路+代码
三角直接想象成一个只有一半的二维数组
第三行开始，不在两端的数字，就是左上和正上数字的和]]></description><category></category></item><item><title><![CDATA[LeetCode 88. 合并两个有序数组 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/120445900</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/120445900</guid><author>Cold__Winter</author><pubDate>Fri, 24 Sep 2021 00:13:10 +0800</pubDate><description><![CDATA[题目描述
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：
输入：nums1 = [1,]]></description><category></category></item><item><title><![CDATA[LeetCode 82. 删除排序链表中的重复元素 II Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/115212026</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/115212026</guid><author>Cold__Winter</author><pubDate>Thu, 25 Mar 2021 16:53:36 +0800</pubDate><description><![CDATA[文章目录题目个人思路代码
题目
存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。
返回同样按升序排列的结果链表。
示例 1：


输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]

示例 2：


输入：head = [1,1,1,2,3]
输出：[2,3]

提示：
链表中节点数目在范围 [0, 300] 内
-100 &lt;= Node.val &lt;= 100
题目数据保证链表已经]]></description><category></category></item><item><title><![CDATA[LeetCode 1431. 拥有最多糖果的孩子 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/110791232</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/110791232</guid><author>Cold__Winter</author><pubDate>Mon, 07 Dec 2020 09:50:58 +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 1512. 好数对的数目 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/110658544</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/110658544</guid><author>Cold__Winter</author><pubDate>Fri, 04 Dec 2020 16:51:17 +0800</pubDate><description><![CDATA[题目
给你一个整数数组 nums 。
如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i &lt; j ，就可以认为这是一组 好数对 。
返回好数对的数目。

示例 1：
输入：nums = [1,2,3,1,1,3]
输出：4
解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始


示例 2：
输入：nums = [1,1,1,1]
输出：6
解释：数组中的每组数字都是好数对


示例 3：
输入：nums = [1,2,3]]]></description><category></category></item><item><title><![CDATA[LeetCode 204. 计数质数 Python3]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/110518857</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/110518857</guid><author>Cold__Winter</author><pubDate>Thu, 03 Dec 2020 09:41:49 +0800</pubDate><description><![CDATA[题目
统计所有小于非负整数 n 的质数的数量。

示例 1：
输入：n = 10
输出：4
解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。


示例 2：
输入：n = 0
输出：0


示例 3：
输入：n = 1
输出：0

提示：
0 &lt;= n &lt;= 5000000
个人思路+个人题解（超时）
双循环 一层循环判断，一层循环遍历
为了优化 用了for else 和开方两种方法
from math import sqrt
def isPrime ( a):
   ]]></description><category></category></item><item><title><![CDATA[LintCode 1901. 有序数组的平方 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/109591659</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/109591659</guid><author>Cold__Winter</author><pubDate>Tue, 10 Nov 2020 09:07:54 +0800</pubDate><description><![CDATA[描述
给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
样例

示例1
输入：[-4,-1,0,3,10]
输出：[0,1,9,16,100]


示例2
输入：[-7,-3,2,3,11]
输出：[4,9,9,49,121]

注意事项
1 &lt;= A.length &lt;= 10000
-10000 &lt;= A[i] &lt;= 10000
A 已按非递减顺序排序。
思路+代码
循环计算，排序后返回即可
public class Solution]]></description><category></category></item><item><title><![CDATA[LintCode 1905. 字符删除 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/109572349</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/109572349</guid><author>Cold__Winter</author><pubDate>Mon, 09 Nov 2020 11:29:10 +0800</pubDate><description><![CDATA[题目描述
输入两个字符串，从第一字符串中删除第二个字符串中所有的字符

样例 1:
输入:  str=”They are students”，sub=”aeiou”
输出: ”Thy r stdnts”

注意事项
String contains spaces（包含空格）
1 ≤ len(str),len(sub) ≤​​105
思路+代码
第一反应就是双循环遍历，但是根据提示的长度，感觉会很费时间甚至超时，
所以空间换时间，用一个hash数组记录要删除的字符（对应的ASCII码）。遍历原字符串，把不删的字]]></description><category></category></item><item><title><![CDATA[LeetCode 1470. 重新排列数组 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/109525341</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/109525341</guid><author>Cold__Winter</author><pubDate>Fri, 06 Nov 2020 10:05:52 +0800</pubDate><description><![CDATA[题目：
给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,…,xn,y1,y2,…,yn] 的格式排列。
请你将数组按 [x1,y1,x2,y2,…,xn,yn] 格式重新排列，返回重排后的数组。

示例 1：
输入：nums = [2,5,1,3,4,7], n = 3
输出：[2,3,5,4,1,7]
解释：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7]


示例 2：
输入：nums = [1,2,3,4,4,3,]]></description><category></category></item><item><title><![CDATA[LeetCode 144. 二叉树的前序遍历]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/109310446</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/109310446</guid><author>Cold__Winter</author><pubDate>Tue, 27 Oct 2020 15:14:13 +0800</pubDate><description><![CDATA[给定一个二叉树，返回它的 前序 遍历。
示例:

代码（递归）：
class Solution {
    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();
    public List&lt;Integer&gt; preorderTraversal(TreeNode root) {
        if(root == null){
            return res;
        }
        res.add(root.val)]]></description><category></category></item><item><title><![CDATA[LeetCode 905. 按奇偶排序数组 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108869110</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108869110</guid><author>Cold__Winter</author><pubDate>Tue, 29 Sep 2020 15:23:05 +0800</pubDate><description><![CDATA[题目：
给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
你可以返回满足此条件的任何数组作为答案。

示例：
输入：[3,1,2,4]
输出：[2,4,3,1]
输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。


提示：
1 &lt;= A.length &lt;= 5000
0 &lt;= A[i] &lt;= 5000

思路+代码
双指针
左指针在开始位置
右指针从头遍历，遇见偶数直接换（是本身也换），之后左指针向右移一]]></description><category></category></item><item><title><![CDATA[LeetCode 1207. 独一无二的出现次数 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108703984</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108703984</guid><author>Cold__Winter</author><pubDate>Mon, 21 Sep 2020 10:51:16 +0800</pubDate><description><![CDATA[题目
给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。
如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。

示例 1：
输入：arr = [1,2,2,1,1,3]
输出：true
解释：在该数组中，1 出现了 3 次，2 出现了 2 次，3 只出现了 1 次。没有两个数的出现次数相同。


示例 2：
输入：arr = [1,2]
输出：false


示例 3：
输入：arr = [-3,0,1,-3,1,1,1,-3,10,0]
输出：true

提示：
1 ]]></description><category></category></item><item><title><![CDATA[LeetCode 26.删除排序数组中的重复项 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108577915</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108577915</guid><author>Cold__Winter</author><pubDate>Mon, 14 Sep 2020 14:00:56 +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],
函数应]]></description><category></category></item><item><title><![CDATA[LeetCode 面试题 02.01. 移除重复节点 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108519067</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108519067</guid><author>Cold__Winter</author><pubDate>Thu, 10 Sep 2020 17:29:51 +0800</pubDate><description><![CDATA[题目：
编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。

示例1:
输入：[1, 2, 3, 3, 2, 1]
输出：[1, 2, 3]


示例2:
输入：[1, 1, 1, 1, 2]
输出：[1, 2]


提示：
链表长度在[0, 20000]范围内。
链表元素在[0, 20000]范围内。

思路+代码
刚开始想的是创建一个新的链表，之后通过哈希数组存已经有的节点值，把不重复的添加的新链表中，最后返回新链表。
后来发现可以直接在原链表上操作。用两个指针，前后一起遍历，还是要用哈希数组]]></description><category></category></item><item><title><![CDATA[LeetCode 709. 转换成小写字母 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108493615</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108493615</guid><author>Cold__Winter</author><pubDate>Wed, 09 Sep 2020 17:18:57 +0800</pubDate><description><![CDATA[题目
实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。

示例 1：
输入: “Hello”
输出: “hello”


示例 2：
输入: “here”
输出: “here”


示例 3：
输入: “LOVELY”
输出: “lovely”

思路+个人代码
建立一个字符数组，遍历原str，把字符存入新数组中，其中的大写字母转化为小写字母，其余不变。
要注意其中一点是，字符串中不只有字母。
代码：
class Solut]]></description><category></category></item><item><title><![CDATA[String StringBuilder StringBuffer 简略分析]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108490554</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108490554</guid><author>Cold__Winter</author><pubDate>Wed, 09 Sep 2020 16:53:25 +0800</pubDate><description><![CDATA[之前在做题的时候，遇到了字符串拼接相关问题。当时用String，内存消耗和事件消耗都很大，StringBuilder就没有这种问题，于是查了一些资料，做个小总结。

String
String内部记录值的变量用final修饰，值不可以被直接改变，在拼接的时候每次都要创建新的字符串，耗费一定的时间和空间。在进行大量字符串操作的时候会很难受。

StringBuffer 和 StringBuilder
当对字符串进行修改的时候，推荐使用 StringBuffer 和 StringBuilder 类。
这两个类.]]></description><category></category></item><item><title><![CDATA[LeetCode 804. 唯一摩尔斯密码词 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108469340</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108469340</guid><author>Cold__Winter</author><pubDate>Tue, 08 Sep 2020 15:44:22 +0800</pubDate><description><![CDATA[题目
国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串， 比如: “a” 对应 “.-”, “b” 对应 “-…”, “c” 对应 “-.-.”, 等等。
为了方便，所有26个英文字母对应摩尔斯密码表如下：

[".-","-…","-.-.","-…",".","…-.","–.","…","…",".—","-.-",".-…","–","-.","—",".–.","–.-",".-.","…","-","…-","…-",".–","-…-","-.–","–…"]]></description><category></category></item><item><title><![CDATA[LeetCode 1464. 数组中两元素的最大乘积 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108441911</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108441911</guid><author>Cold__Winter</author><pubDate>Mon, 07 Sep 2020 10:18:50 +0800</pubDate><description><![CDATA[文章目录题目个人思路+代码其他解法：
题目
给你一个整数数组 nums，请你选择数组的两个不同下标 i 和 j，使 (nums[i]-1)*(nums[j]-1) 取得最大值。
请你计算并返回该式的最大值。

示例 1：
输入：nums = [3,4,5,2]
输出：12
解释：如果选择下标 i=1 和 j=2（下标从 0 开始），则可以获得最大值，(nums[1]-1)(nums[2]-1) = (4-1)(5-1) = 3*4 = 12 。


示例 2：
输入：nums = [1,5,4,5]
输出：]]></description><category></category></item><item><title><![CDATA[LeetCode 104. 二叉树的最大深度 Java]]></title><link>https://blog.youkuaiyun.com/Cold__Winter/article/details/108407845</link><guid>https://blog.youkuaiyun.com/Cold__Winter/article/details/108407845</guid><author>Cold__Winter</author><pubDate>Fri, 04 Sep 2020 17:09:26 +0800</pubDate><description><![CDATA[题目
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

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


返回它的最大深度 3 。
思路+代码
带着深度递归，通过判断是否遍历到null，使递归到叶子节点的时候会返回深度，之后获取返回的深度的最大值就可以了。
代码：
class Solution {

    public int Depth(TreeNode root, int deep) {
   ]]></description><category></category></item></channel></rss>