<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[han_qing1213的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/han_qing1213</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; han_qing1213]]></copyright><item><title><![CDATA[Leetcode：回文数]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119960559</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119960559</guid><author>han_qing1213</author><pubDate>Fri, 27 Aug 2021 21:21:29 +0800</pubDate><description><![CDATA[题目

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。


示例 1：
输入：x = 121 输出：true
示例 2：
输入：x = -121 输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例
3：
输入：x = 10 输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
示]]></description><category></category></item><item><title><![CDATA[LeetCode：整数反转]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119940524</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119940524</guid><author>han_qing1213</author><pubDate>Thu, 26 Aug 2021 21:38:15 +0800</pubDate><description><![CDATA[题目

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。


示例 1：
输入：x = 123 输出：321
示例 2：
输入：x = -123 输出：-321
示例 3：
输入：x = 120 输出：21
示例 4：
输入：x = 0 输出：0

解题思路
方法1（除余）：
（1）如果绝对值小于10，直接return；
（2）先]]></description><category></category></item><item><title><![CDATA[LeetCode：两数之和]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119919755</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119919755</guid><author>han_qing1213</author><pubDate>Wed, 25 Aug 2021 21:20:54 +0800</pubDate><description><![CDATA[题目

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个
整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。


示例 1：
输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] ==
9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], targ]]></description><category></category></item><item><title><![CDATA[LeetCode：存在重复元素]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119898415</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119898415</guid><author>han_qing1213</author><pubDate>Wed, 25 Aug 2021 21:08:26 +0800</pubDate><description><![CDATA[题目

给定一个整数数组，判断是否存在重复元素。
如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。


示例 1:
输入: [1,2,3,1] 输出: true
示例 2:
输入: [1,2,3,4] 输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2] 输出: true

解题思路
1、set()可以去掉重复的元素，如果有相同元素的话set一定会比原列表长度短
代码实现
class Solution:
    def ]]></description><category></category></item><item><title><![CDATA[Leetcode：查找重复的电子邮箱]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119878904</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119878904</guid><author>han_qing1213</author><pubDate>Mon, 23 Aug 2021 22:12:58 +0800</pubDate><description><![CDATA[题目
编写一个 SQL 查询，查找 Person 表中所有重复的电子邮箱。
示例：
±—±--------+
| Id | Email   |
±—±--------+
| 1  | a@b.com |
| 2  | c@d.com |
| 3  | a@b.com |
±—±--------+
根据以上输入，你的查询应返回以下结果：
±--------+
| Email   |
±--------+
| a@b.com |
±--------+
代码实现
解法1：
select distinct p1.e]]></description><category></category></item><item><title><![CDATA[LeetCode：超过经理收入的员工]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119878756</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119878756</guid><author>han_qing1213</author><pubDate>Mon, 23 Aug 2021 22:05:33 +0800</pubDate><description><![CDATA[题目
Employee 表包含所有员工，他们的经理也属于员工。每个员工都有一个 Id，此外还有一列对应员工的经理的 Id。
±—±------±-------±----------+
| Id | Name  | Salary | ManagerId |
±—±------±-------±----------+
| 1  | Joe   | 70000  | 3         |
| 2  | Henry | 80000  | 4         |
| 3  | Sam   | 60000  | NU]]></description><category></category></item><item><title><![CDATA[LeetCode：组合两个表]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119878505</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119878505</guid><author>han_qing1213</author><pubDate>Mon, 23 Aug 2021 21:51:21 +0800</pubDate><description><![CDATA[题目
表1: Person
±------------±--------+
| 列名         | 类型     |
±------------±--------+
| PersonId    | int     |
| FirstName   | varchar |
| LastName    | varchar |
±------------±--------+
PersonId 是上表主键
表2: Address
±------------±--------+
| 列名         | 类型]]></description><category></category></item><item><title><![CDATA[LeetCode：第二高的薪水]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119878451</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119878451</guid><author>han_qing1213</author><pubDate>Mon, 23 Aug 2021 21:47:24 +0800</pubDate><description><![CDATA[题目

编写一个 SQL 查询，获取 Employee 表中第二高的薪水（Salary） 。
±—±-------+
| Id | Salary |
±—±-------+
| 1  | 100    |
| 2  | 200    |
| 3  | 300    |
±—±-------+
例如上述 Employee 表，SQL查询应该返回 200 作为第二高的薪水。如果不存在第二高的薪水，那么查询应返回 null。

解题思路
（1）要想获取第二高，需要排序，使用 order by（默认是升序 asc，]]></description><category></category></item><item><title><![CDATA[LeetCode：阶乘后的零]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119852438</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119852438</guid><author>han_qing1213</author><pubDate>Sun, 22 Aug 2021 14:46:41 +0800</pubDate><description><![CDATA[题目

给定一个整数 n，返回 n! 结果尾数中零的数量。
示例 1:
输入: 3 输出: 0 解释: 3! = 6, 尾数中没有零。
示例 2:
输入: 5 输出: 1 解释: 5! = 120, 尾数中有 1 个零.
说明: 你算法的时间复杂度应为 O(log n) 。

解题思路
方法1（暴力解法）：
（1）先计算出n的阶乘，再计算值里面有多少个0
方法2（乘因子的个数）：
（1）一个5就可生成一个0 ，则有多少个5就能生成多少个0。计算当前数值中有多少个乘因子为5即可。
（2）需要注意25、125等]]></description><category></category></item><item><title><![CDATA[LeetCode：多数元素]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119842380</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119842380</guid><author>han_qing1213</author><pubDate>Sat, 21 Aug 2021 17:37:41 +0800</pubDate><description><![CDATA[题目

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。


示例 1：
输入：[3,2,3] 输出：3
示例 2：
输入：[2,2,1,1,1,2,2] 输出：2
进阶：
尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。

解题思路
方法1（统计）：
（1）先对列表元素进行排序，这样相同元素可排列在一起；
（2）通过遍历对比当前元素和前一个元素是否相等，相等时co]]></description><category></category></item><item><title><![CDATA[LeetCode：Excel表列名称&Excel 表列序号]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119840340</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119840340</guid><author>han_qing1213</author><pubDate>Sat, 21 Aug 2021 16:06:10 +0800</pubDate><description><![CDATA[题目

给你一个整数 columnNumber ，返回它在 Excel 表中相对应的列名称。
例如：
A -&gt; 1
B -&gt; 2
C -&gt; 3
…
Z -&gt; 26
AA -&gt; 27
AB -&gt; 28
…
示例 1：
输入：columnNumber = 1 输出：“A”
示例 2：
输入：columnNumber = 28 输出：“AB”
示例 3：
输入：columnNumber = 701 输出：“ZY”
示例 4：
输入：columnNumber = 21474836]]></description><category></category></item><item><title><![CDATA[LeetCode： 两数之和 II - 输入有序数组]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119813043</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119813043</guid><author>han_qing1213</author><pubDate>Thu, 19 Aug 2021 23:13:08 +0800</pubDate><description><![CDATA[题目

给定一个已按照 升序排列  的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 &lt;=
answer[0] &lt; answer[1] &lt;= numbers.length 。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。


示例 1：
输入：numbers = [2,7,11,15], tar]]></description><category></category></item><item><title><![CDATA[Leetcode:二叉树的后序遍历]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119812319</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119812319</guid><author>han_qing1213</author><pubDate>Thu, 19 Aug 2021 23:02:19 +0800</pubDate><description><![CDATA[题目

给定一个二叉树，返回它的 后序 遍历。
示例:
输入: [1,null,2,3]
输出: [3,2,1]

解题思路
（1）后序遍历：左节点-右节点-根节点
（2）递归获取
代码实现
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = le]]></description><category></category></item><item><title><![CDATA[Leetcode:二叉树的前序遍历]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119812266</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119812266</guid><author>han_qing1213</author><pubDate>Thu, 19 Aug 2021 22:12:23 +0800</pubDate><description><![CDATA[题目

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
示例 1：
输入：root = [1,null,2,3] 输出：[1,2,3]
示例 2：
输入：root = [] 输出：[]
示例 3：
输入：root = [1] 输出：[1]
示例 4：
输入：root = [1,2] 输出：[1,2]
示例 5：
输入：root = [1,null,2] 输出：[1,2]

解题思路
（1）前序遍历为：根节点-左节点-右节点
（2）递归获取
代码实现
# Definition for a bin]]></description><category></category></item><item><title><![CDATA[Leetcode：只出现一次的数字]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119789481</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119789481</guid><author>han_qing1213</author><pubDate>Wed, 18 Aug 2021 21:38:15 +0800</pubDate><description><![CDATA[题目

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？


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

解题思路
方法1（数组内比较）：
（1）对数组进行排序
（2）如果第一个元素和第二个元素不相同，则直接返回第一个元素；如果最后两个元素不一样，则直接返回最后一个。
（3）从第二个数字开始，比较它和前一位、后一位数字是]]></description><category></category></item><item><title><![CDATA[LeetCode：买卖股票的最佳时机 II]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119788635</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119788635</guid><author>han_qing1213</author><pubDate>Wed, 18 Aug 2021 20:48:59 +0800</pubDate><description><![CDATA[题目

给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。


示例 1:
输入: prices = [7,1,5,3,6,4] 输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格
= 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价]]></description><category></category></item><item><title><![CDATA[LeetCode：买卖股票的最佳时机]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119766491</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119766491</guid><author>han_qing1213</author><pubDate>Tue, 17 Aug 2021 21:38:34 +0800</pubDate><description><![CDATA[题目

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。


示例 1：
输入：[7,1,5,3,6,4] 输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能]]></description><category></category></item><item><title><![CDATA[LeetCode：杨辉三角1和2]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119742166</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119742166</guid><author>han_qing1213</author><pubDate>Mon, 16 Aug 2021 21:26:50 +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]]

题目二：

给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。
示例 1:
]]></description><category></category></item><item><title><![CDATA[LeetCode：二叉树的中序遍历]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119719519</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119719519</guid><author>han_qing1213</author><pubDate>Sun, 15 Aug 2021 20:44:08 +0800</pubDate><description><![CDATA[题目

给定一个二叉树的根节点 root ，返回它的 中序 遍历。
示例 1： 输入：root = [1,null,2,3] ，输出：[1,3,2]
示例 2：
输入：root = [] 输出：[]
示例 3：
输入：root = [1] 输出：[1]

解题思路：
直接递归遍历访问左结点、根节点、右节点
代码实现：
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None]]></description><category></category></item><item><title><![CDATA[LeetCode：二进制求和]]></title><link>https://blog.youkuaiyun.com/han_qing1213/article/details/119713005</link><guid>https://blog.youkuaiyun.com/han_qing1213/article/details/119713005</guid><author>han_qing1213</author><pubDate>Sun, 15 Aug 2021 14:05:55 +0800</pubDate><description><![CDATA[题目

给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。


示例 1:
输入: a = “11”, b = “1”
输出: “100”
示例 2:
输入: a = “1010”, b = “1011”
输出: “10101”

解题思路
1、由于两个字符串中的元素都会参与计算，为防止溢出异常，先将短的那个字符串添加‘0’至两个字符串长度相同。
2、如果其中有个为空字符串，则直接返回另一个字符串。
3、加法都是从最右侧的数字开始，因此字符串也得从最后一个字]]></description><category></category></item></channel></rss>