<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[fuzzy__H的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/fuzzy__H</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; fuzzy__H]]></copyright><item><title><![CDATA[摩尔投票算法]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/118676502</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/118676502</guid><author>fuzzy__H</author><pubDate>Mon, 12 Jul 2021 16:32:52 +0800</pubDate><description><![CDATA[摩尔投票算法认定的事实


每次从序列里选择两个不相同的数字相抵消，最后剩下一个数字或几个相同的数字，就是出现次数大于总数一半的那个。


上面就是摩尔投票算法认定的事实。基于以上事实，编写摩尔投票算法代码。
思路
对于一个序列，先维护一个默认主要元素major（可为任意值）和一个主要元素计数count（初始化为0）。
遍历这个序列：
如果count为0，则说明还没有找到主要元素，则可把当前元素当作主要元素，同时count累加1，
if(count == 0)
{
	major = nums[i];
	co]]></description><category></category></item><item><title><![CDATA[合并二叉树（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/108711647</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/108711647</guid><author>fuzzy__H</author><pubDate>Mon, 21 Sep 2020 15:37:59 +0800</pubDate><description><![CDATA[题目描述
给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

解题思路
二叉树-递归解决
采用先序遍历，同时遍历两棵树，若有一个为空则返回另一个，否则将两个节点的值相加，可在其中一棵树上操作，最后返回这棵树的根节点。
代码实现
# Definition for a binary tree node.
# class]]></description><category></category></item><item><title><![CDATA[初始化Python多维列表（list）的坑]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107978695</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107978695</guid><author>fuzzy__H</author><pubDate>Thu, 13 Aug 2020 14:29:07 +0800</pubDate><description><![CDATA[刷题过程中采用两种方式对一个多维列表进行初始化，最后得到的结果不同，很是疑惑，后来发现两种初始化方式是有区别的！
capacity = 10
num = 5
valueExcel = [[0 for j in range(capacity + 1)] for i in range(num + 1)]
valueExcel2 = [[0]*(capacity+1)]*(num+1)
# 这两种方式都可以得到6*11的初始值为0的列表，但在后续赋值操作中，却得到了截然不同的结果。
# 对valueExcel赋值]]></description><category></category></item><item><title><![CDATA[二叉树中的最大路径和-递归实现（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107630125</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107630125</guid><author>fuzzy__H</author><pubDate>Tue, 28 Jul 2020 11:06:36 +0800</pubDate><description><![CDATA[题目描述
给定一个非空二叉树，返回其最大路径和。
本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。
示例1：

示例2：

解题思路
遇到二叉树的题，如果能用递归就尽量递归吧。
首先回顾递归三步骤：
1、递归终止条件及返回值
2、递推条件
3、返回值分析处理
具体到这道题，采用递归的三个步骤具体化为：
1、递归终止条件为节点为空，返回值为0
2、递推条件：分别递归左右子树，计算左右子树的节点和记为l和r
3、返回值及分析：max(0, l, r) ]]></description><category></category></item><item><title><![CDATA[将有序链表转换为二叉搜索树（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107611793</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107611793</guid><author>fuzzy__H</author><pubDate>Mon, 27 Jul 2020 15:32:24 +0800</pubDate><description><![CDATA[题目描述
给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

解题思路
这道题和“将有序列表转换为二叉搜索树”思路是一样的。
在题目“将有序列表转换为二叉搜索树”中，我们利用列表的索引，可以方便地找到列表的中点（当列表长度为偶数时，此处默认后一个为中点），并利用列表的切片索引，递归的构建搜索二叉树的左右子树（中点左边的作为左子树的列表输入，中点右边的列表作为右子树的列表输入），代码1 中将给出]]></description><category></category></item><item><title><![CDATA[二叉树最近公共祖先（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107538797</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107538797</guid><author>fuzzy__H</author><pubDate>Thu, 23 Jul 2020 16:03:38 +0800</pubDate><description><![CDATA[题目描述
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉树:  root = [3,5,1,6,2,0,8,null,null,7,4]


说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。
解题思路
具体思路：
使用递归，时间复杂度O(n)。
1、递归终止条件]]></description><category></category></item><item><title><![CDATA[二叉树的最小深度（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107501115</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107501115</guid><author>fuzzy__H</author><pubDate>Tue, 21 Jul 2020 23:03:11 +0800</pubDate><description><![CDATA[题目描述
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。
解题思路
这里需要注意的是，当一棵树只有一个叶子节点的时候，其最小深度为2，这种情况需要特殊考虑一下。
用递归实现本题。
代码实现
class Solution:
    def minDepth(self, root: TreeNode) -&gt; int:
        if not root:
            return 0
        l_h]]></description><category></category></item><item><title><![CDATA[不同的二叉搜索树（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107490203</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107490203</guid><author>fuzzy__H</author><pubDate>Tue, 21 Jul 2020 15:50:59 +0800</pubDate><description><![CDATA[题目描述
给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。
解题思路
首先要明确二叉搜索树的重要性质二叉搜索性即一棵二叉搜索树的根节点的值大于左子树所有节点的值，小于右子树所有节点的值，且左子树和右子树也同样为二叉搜索树。假设当前序列长度为 nn，如果我们枚举根节点的值为 ii，那么根据二叉搜索树的性质我们可以知道左子树的节点值的集合为 [1…i−1]，右子树的节点值的集合为 [i+1…n]。而左子树和右子树的生成相较于原问题是一个序列长度缩小的子问题，因此我们可以想到用递归的方法来]]></description><category></category></item><item><title><![CDATA[二叉树的序列化与反序列化（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107489663</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107489663</guid><author>fuzzy__H</author><pubDate>Tue, 21 Jul 2020 15:24:52 +0800</pubDate><description><![CDATA[题目描述
请实现两个函数，分别用来序列化和反序列化二叉树。
您需要确保二叉树可以序列化为字符串，并且可以将此字符串反序列化为原始树结构。
解题思路
深度优先遍历
1、序列化的过程可以采用深度优先遍历方法，此处采用先序遍历
2、对于将一棵二叉树的先序遍历结果（采用列表存储），第一个元素为二叉树的根节点，剩余元素可以看成由根节点的左右子树构成，而每一棵子树又是一棵二叉树。
3、对于2中的描述，故可以采用递归的方法，由一棵二叉树的先序遍历结果来还原一棵树（由于序列化过程中会将叶子节点的空指针保存，故可以还原）。
]]></description><category></category></item><item><title><![CDATA[ACWing 88.树中两个节点的最低公共祖先（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107101588</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107101588</guid><author>fuzzy__H</author><pubDate>Fri, 03 Jul 2020 11:12:35 +0800</pubDate><description><![CDATA[题目描述
给出一个二叉树，输入两个树节点，求它们的最低公共祖先。
一个树节点的祖先节点包括它本身。
注意：
输入的二叉树不为空；
输入的两个节点一定不为空，且是二叉树中的节点；
样例：

解题思路
见注释
代码实现
class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :]]></description><category></category></item><item><title><![CDATA[AcWing 85.不用加减乘除做加法（奇葩Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107073923</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107073923</guid><author>fuzzy__H</author><pubDate>Wed, 01 Jul 2020 23:13:21 +0800</pubDate><description><![CDATA[题目描述
写一个函数，求两个整数之和，要求在函数体内不得使用＋、－、×、÷ 四则运算符号。
解题思路
设两数的二进制形式为a, b，则两数之和S = 非进位和 + 进位，同时非进位和与异或运算规律相同，进位与与运算规律相同（需左移一位）。
设n = a异或b, c = a&amp;b&lt;&lt;1,循环求n和c，直至进位c = 0，此时和S = n，返回n即可。
知道上述规律之后，代码写起来似乎很简单，但如果你用Python写的话，就会遇到一个很奇葩的问题：在C、C++、Java中负数都是以补码形式存储]]></description><category></category></item><item><title><![CDATA[AcWing 83.股票的最大利润（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/107059745</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/107059745</guid><author>fuzzy__H</author><pubDate>Wed, 01 Jul 2020 11:32:49 +0800</pubDate><description><![CDATA[题目描述
假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖 一次 该股票可能获得的利润是多少？
例如一只股票在某些时间节点的价格为[9, 11, 8, 5, 7, 12, 16, 14]。
如果我们能在价格为5的时候买入并在价格为16时卖出，则能收获最大的利润11。
样例：

解题思路
1、首先想到暴力法
每一个元素都当做最低价，往后遍历找到最高差价，时间复杂度O（n^2），LeetCode上无法通过
2、一次遍历法
用一个变量记录遍历过的元素中的最低价，寻找当前价与最低价之间的最高差价：即在遍历过]]></description><category></category></item><item><title><![CDATA[LeetCode67.二进制求和（Python版竖式相加思路）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/106932900</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/106932900</guid><author>fuzzy__H</author><pubDate>Tue, 23 Jun 2020 22:03:20 +0800</pubDate><description><![CDATA[题目描述
给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。
示例 1:

提示：
每个字符串仅由字符 ‘0’ 或 ‘1’ 组成。
1 &lt;= a.length, b.length &lt;= 10^4
字符串如果不是 “0” ，就都不含前导零。
解题思路
首先想到的是用竖式相加，但需要处理一个问题就是竖式相加时是低位对齐，而字符串索引是从高位开始索引的，故需要先将字符串翻转，再对短的字符串进行补零（这样在索引时不会越界）；翻转后对位相加，再将最后的结果]]></description><category></category></item><item><title><![CDATA[AcWing 79.滑动窗口的最大值（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/106818699</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/106818699</guid><author>fuzzy__H</author><pubDate>Wed, 17 Jun 2020 21:41:14 +0800</pubDate><description><![CDATA[题目描述
给定一个数组和滑动窗口的大小，请找出所有滑动窗口里的最大值。
例如，如果输入数组[2, 3, 4, 2, 6, 2, 5, 1]及滑动窗口的大小3,那么一共存在6个滑动窗口，它们的最大值分别为[4, 4, 6, 6, 6, 5]。
数据保证k大于0，且k小于等于数组长度。
解题思路
1、如果k等于nums数组的长度，则返回nums中最大值
2、如果小于nums数组长度，则可以先遍历前k个元素，找出最大的值的下标记作max_ind，再利用两个指针，头指针指向第k个元素，尾指针指向第2个元素，然后让两]]></description><category></category></item><item><title><![CDATA[LeetCode 76.最小覆盖子串（滑动窗口解法Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/106645042</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/106645042</guid><author>fuzzy__H</author><pubDate>Tue, 09 Jun 2020 16:53:04 +0800</pubDate><description><![CDATA[题目描述
给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字符的最小子串。

解题思路
LeetCode 上已经有很多大神写解题思路了，我也是看大神的思路写的。
此处记录我自己的理解过程。
滑动窗口是双指针的高级技巧，首先得定义两个指针，left和right，在窗口[left, right]中寻找符合题意的解，如何寻找这样的解即滑动窗口的核心思想。就题解题：
1、首先定义两个字典window和need，need记录T，window记录窗口中的字符出现次数
2、首先让右指针不断向右]]></description><category></category></item><item><title><![CDATA[ACWing 73.数组中只出现一次的两个数]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/106570524</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/106570524</guid><author>fuzzy__H</author><pubDate>Fri, 05 Jun 2020 15:23:16 +0800</pubDate><description><![CDATA[题目描述
一个整型数组里除了两个数字之外，其他的数字都出现了两次。
请写程序找出这两个只出现一次的数字。
你可以假设这两个数字一定存在。
样例：

思路1
首先想到的是使用哈希表，统计每个数字出现的频数，最后再遍历哈希表，找出只出现一次的数字。这样的时间复杂度为O(n)，空间复杂度为O(n)。问题解决。实现代码如下：
思路1代码
class Solution(object):
    def findNumsAppearOnce(self, nums):
        """
        :type ]]></description><category></category></item><item><title><![CDATA[AcWing 75. 和为S的两个数字（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/106559868</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/106559868</guid><author>fuzzy__H</author><pubDate>Thu, 04 Jun 2020 22:45:57 +0800</pubDate><description><![CDATA[题目描述
输入一个数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。
如果有多对数字的和等于s，输出任意一对即可。
你可以认为每组输入中都至少含有一组满足条件的输出。
样例：

思路1
对于在数组中找两数之和的题目，首先想到的是用哈希表，（暴力搜索法时间复杂度为n^2,不考虑），哈希表的查询时间为 O(1)，算法的时间复杂度降低到 O(N)，但是需要 O(N) 的空间复杂度来存储哈希表。首先给出哈希表的解法代码
哈希表实现
class Solution(object):
    def findN]]></description><category></category></item><item><title><![CDATA[AcWing 72.平衡二叉树（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/106535489</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/106535489</guid><author>fuzzy__H</author><pubDate>Wed, 03 Jun 2020 23:31:58 +0800</pubDate><description><![CDATA[题目描述
输入一棵二叉树的根结点，判断该树是不是平衡二叉树。
如果某二叉树中任意结点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
注意：

规定空树也是一棵平衡二叉树。

样例：

解题思路
对于平衡二叉树，其每一个节点的左右子树的深度相差不超过1，所以需要做两件事：
1、遍历每一个节点
2、求出每个节点左右子树的深度差
对于1，应该用递归对树的节点进行遍历；
对于2，因为之前做过一道求二叉树的深度的题，所以直接拿来用。实现代码如下：
代码实现
class Solution(object):
 ]]></description><category></category></item><item><title><![CDATA[AcWing 55.连续子数组的最大和（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/106491728</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/106491728</guid><author>fuzzy__H</author><pubDate>Tue, 02 Jun 2020 11:07:43 +0800</pubDate><description><![CDATA[题目描述
输入一个 非空 整型数组，数组里的数可能为正，也可能为负。
数组中一个或连续的多个整数组成一个子数组。
求所有子数组的和的最大值。
要求时间复杂度为O(n)。
样例：

解题思路
Kadane算法
Kadane全名叫Joseph “Jay” Born Kadane，是卡耐基梅隆大学的统计学方面的教授，于1984年提出提出了线性解决这个问题的办法。该算法的核心思路是判断以前一个元素结尾的子序列的最大值能不能给当前元素结尾的序列提供增益。就比如例子中的子序列[1, -2, 3]，在判断3这个元素是否应]]></description><category></category></item><item><title><![CDATA[AcWing 49.二叉搜索树与双向链表（Python版）]]></title><link>https://blog.youkuaiyun.com/fuzzy__H/article/details/106426140</link><guid>https://blog.youkuaiyun.com/fuzzy__H/article/details/106426140</guid><author>fuzzy__H</author><pubDate>Fri, 29 May 2020 15:28:03 +0800</pubDate><description><![CDATA[题目描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。

要求不能创建任何新的结点，只能调整树中结点指针的指向。

注意：
需要返回双向链表最左侧的节点。
例如，输入下图中左边的二叉搜索树，则输出右边的排序双向链表。

思路
对于一棵二叉搜索树，其中序遍历结果为升序的有序结果，以例中的二叉搜索树为例，其中序遍历结果为[4,6,8,10,12,14,16]。
由于题中要求不能创建新的结点，且只能调整树中结点指针的指向，故可以将树的节点按照中序遍历的顺序记录在列表中，再遍历该列表，将当前节点的右]]></description><category></category></item></channel></rss>