<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Gzbgreat的博客]]></title><description><![CDATA[长路漫漫，乞相伴而行啊。]]></description><link>https://blog.csdn.net/GreatJames</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; GreatJames]]></copyright><item><title><![CDATA[（链表）2. 两数相加]]></title><link>https://blog.csdn.net/GreatJames/article/details/108500936</link><guid>https://blog.csdn.net/GreatJames/article/details/108500936</guid><author>GreatJames</author><pubDate>Wed, 09 Sep 2020 19:56:25 +0800</pubDate><description><![CDATA[给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4)
输出：7 -&gt; 0 -&gt; 8
原因：342 + 465 = 807
题解思路
将当前结点初始化为返回列表的哑结点。
将进位carry 初始]]></description><category></category></item><item><title><![CDATA[（二叉树）538. 把二叉搜索树转换为累加树]]></title><link>https://blog.csdn.net/GreatJames/article/details/108500146</link><guid>https://blog.csdn.net/GreatJames/article/details/108500146</guid><author>GreatJames</author><pubDate>Wed, 09 Sep 2020 19:15:17 +0800</pubDate><description><![CDATA[给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

题解思路
二叉搜索树的中序遍历的反序是一个降序数组，因此只需用一个sum记录到当前节点为止的所有数组和，并把这个值更新到二叉树的root节点即可，这样每个节点存的值就是原来节点值加上所有大于它节点的值之和
实现代码
class Solution {
    int sum = 0;
    public TreeNode convertBS]]></description><category></category></item><item><title><![CDATA[（二叉树）617. 合并二叉树]]></title><link>https://blog.csdn.net/GreatJames/article/details/108466044</link><guid>https://blog.csdn.net/GreatJames/article/details/108466044</guid><author>GreatJames</author><pubDate>Tue, 08 Sep 2020 12:08:19 +0800</pubDate><description><![CDATA[给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

注意: 合并必须从两个树的根节点开始。
题解思路
在遍历时，如果两棵树的当前节点均不为空，我们就将它们的值进行相加，并对它们的左孩子和右孩子进行递归合并；如果其中有一棵树为空，那么我们返回另一颗树作为结果；如果两棵树均为空，此时返回任意一棵树均可（因为都是空）
实]]></description><category></category></item><item><title><![CDATA[（链表）82. 删除排序链表中的重复元素 II]]></title><link>https://blog.csdn.net/GreatJames/article/details/108463275</link><guid>https://blog.csdn.net/GreatJames/article/details/108463275</guid><author>GreatJames</author><pubDate>Tue, 08 Sep 2020 10:24:02 +0800</pubDate><description><![CDATA[给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。
示例 1:
输入: 1-&gt;2-&gt;3-&gt;3-&gt;4-&gt;4-&gt;5
输出: 1-&gt;2-&gt;5
示例 2:
输入: 1-&gt;1-&gt;1-&gt;2-&gt;3
输出: 2-&gt;3
题解思路
为了防止删除头结点的极端情况发生，先创建空结点dummy，使dummy指向传入的head结点。
然后创建cur的指针，指向链表的头部（即dummy）。
接着对cur指针迭代，因为要对比c]]></description><category></category></item><item><title><![CDATA[（链表）83. 删除排序链表中的重复元素]]></title><link>https://blog.csdn.net/GreatJames/article/details/108461403</link><guid>https://blog.csdn.net/GreatJames/article/details/108461403</guid><author>GreatJames</author><pubDate>Tue, 08 Sep 2020 09:11:42 +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
题解思路
指定 cur 指针指向头部 head
当 cur 和 cur.next 的存在为循环结束条件，当二者有一个不存在时说明链表没有去重复的必要了
当 cur.val 和 cur.next.val 相等时说明需要去重，则将 cur 的下一个指针指向下一个的下一个，]]></description><category></category></item><item><title><![CDATA[（数组）59. 螺旋矩阵 II]]></title><link>https://blog.csdn.net/GreatJames/article/details/108449301</link><guid>https://blog.csdn.net/GreatJames/article/details/108449301</guid><author>GreatJames</author><pubDate>Mon, 07 Sep 2020 15:41:35 +0800</pubDate><description><![CDATA[给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:
输入: 3
输出:
[
[ 1, 2, 3 ],
[ 8, 9, 4 ],
[ 7, 6, 5 ]
]
题解思路

实现代码
public class Solution02 {
    public int[][] generateMatrix(int n) {
        int[][] matrix = new int[n][n];
        int left = 0, right = ]]></description><category></category></item><item><title><![CDATA[（数组）54. 螺旋矩阵]]></title><link>https://blog.csdn.net/GreatJames/article/details/108448787</link><guid>https://blog.csdn.net/GreatJames/article/details/108448787</guid><author>GreatJames</author><pubDate>Mon, 07 Sep 2020 15:21:46 +0800</pubDate><description><![CDATA[给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。
示例 1:
输入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]
示例 2:
输入:
[
[1, 2, 3, 4],
[5, 6, 7, 8],
[9,10,11,12]
]
输出: [1,2,3,4,8,12,11,10,9,5,6,7]
题解思路

实现代码
public class Solution {
    ]]></description><category></category></item><item><title><![CDATA[（二叉树）剑指 Offer 27. 二叉树的镜像]]></title><link>https://blog.csdn.net/GreatJames/article/details/108425937</link><guid>https://blog.csdn.net/GreatJames/article/details/108425937</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 23:07:41 +0800</pubDate><description><![CDATA[请完成一个函数，输入一个二叉树，该函数输出它的镜像。

示例 1：
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
题解思路
终止条件： 当节点 root为空时（即越过叶节点），则返回 null ；
递推工作：
初始化节点 tmp ，用于暂存 root 的左子节点；
开启递归 右子节点 mirrorTree(root.right) ，并将返回值作为 root 的 左子节点 。
开启递归 左子节点 mirrorTree(tmp) ，并将返回值作为 root 的 右子节]]></description><category></category></item><item><title><![CDATA[（二叉树）226. 翻转二叉树]]></title><link>https://blog.csdn.net/GreatJames/article/details/108425883</link><guid>https://blog.csdn.net/GreatJames/article/details/108425883</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 22:59:32 +0800</pubDate><description><![CDATA[翻转一棵二叉树。
题解思路
其实就是交换一下左右节点，然后再递归的交换左节点，右节点
根据动画图我们可以总结出递归的两个条件如下：
终止条件：当前节点为null时返回
交换当前节点的左右节点，再递归的交换当前节点的左节点，递归的交换当前节点的右节点
实现代码
class Solution {
	public TreeNode invertTree(TreeNode root) {
		//递归函数的终止条件，节点为空时返回
		if(root==null) {
			return null;
		}
		/]]></description><category></category></item><item><title><![CDATA[（二叉树）剑指 Offer 28. 对称的二叉树]]></title><link>https://blog.csdn.net/GreatJames/article/details/108425760</link><guid>https://blog.csdn.net/GreatJames/article/details/108425760</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 22:52:44 +0800</pubDate><description><![CDATA[请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

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

示例 1：
输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
输入：root = [1,2,2,null,3,null,3]
输出：false
题解思路
如果两颗树的根都为空，返回true
如果一颗为空另一颗不为空返回false
如果两颗都不为空]]></description><category></category></item><item><title><![CDATA[（链表）12. 相交链表]]></title><link>https://blog.csdn.net/GreatJames/article/details/108425680</link><guid>https://blog.csdn.net/GreatJames/article/details/108425680</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 22:43:56 +0800</pubDate><description><![CDATA[输入两个链表，找出它们的第一个公共节点。
题解思路
指针 pA 指向 A 链表，指针 pB 指向 B 链表，依次往后遍历
如果 pA 到了末尾，则 pA = headB 继续遍历
如果 pB 到了末尾，则 pB = headA 继续遍历
比较长的链表指针指向较短链表head时，长度差就消除了
如此，只需要将最短链表遍历两次即可找到位置
实现代码
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, Li]]></description><category></category></item><item><title><![CDATA[（链表）11. 单链表反转]]></title><link>https://blog.csdn.net/GreatJames/article/details/108425661</link><guid>https://blog.csdn.net/GreatJames/article/details/108425661</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 22:39:48 +0800</pubDate><description><![CDATA[定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL
输出: 5-&gt;4-&gt;3-&gt;2-&gt;1-&gt;NULL
题解思路
双指针实现
实现代码
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = hea]]></description><category></category></item><item><title><![CDATA[（链表）3.	有序链表合并]]></title><link>https://blog.csdn.net/GreatJames/article/details/108425608</link><guid>https://blog.csdn.net/GreatJames/article/details/108425608</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 22:35:59 +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
题解思路
终止条件：两条链表分别名为 l1 和 l2，当 l1 为空或 l2 为空时结束
返回值：每一层调用都返回排序好的链表头
本级递归内容：如果 l1 的 val 值更小，则将 l1.next 与排序好的链表头相接，l2 同理
O(m+n)，m 为 l1的长度，n 为]]></description><category></category></item><item><title><![CDATA[（二叉树）11. 一颗二叉树是否是二叉搜索树]]></title><link>https://blog.csdn.net/GreatJames/article/details/108417859</link><guid>https://blog.csdn.net/GreatJames/article/details/108417859</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 12:13:50 +0800</pubDate><description><![CDATA[给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:

示例 2:

题解思路
中序遍历时，判断当前节点是否大于中序遍历的前一个节点，如果大于，说明满足 BST，继续遍历；否则直接返回 false
实现代码
class Solution {
    int pre = Integer.MIN_VALUE;
    public boolean i]]></description><category></category></item><item><title><![CDATA[（二叉树）剑指 Offer 54. 二叉搜索树的第k大节点]]></title><link>https://blog.csdn.net/GreatJames/article/details/108415758</link><guid>https://blog.csdn.net/GreatJames/article/details/108415758</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 09:57:59 +0800</pubDate><description><![CDATA[给定一棵二叉搜索树，请找出其中第k大的节点。
示例 1:
输入: root = [3,1,4,null,2], k = 1

示例 2:
输入: root = [5,3,6,2,4,null,null,1], k = 3

限制：
1 ≤ k ≤ 二叉搜索树元素个数
题解思路
二叉搜索树的中序遍历为 递增序列
所以二叉搜索树的 中序遍历倒序 为 递减序列 。
因此，求 “二叉搜索树第 k 大的节点” 可转化为求 “此树的中序遍历倒序的第 k 个节点”。
实现代码
class Solution {
    i]]></description><category></category></item><item><title><![CDATA[（二叉树）110. 平衡二叉树]]></title><link>https://blog.csdn.net/GreatJames/article/details/108414945</link><guid>https://blog.csdn.net/GreatJames/article/details/108414945</guid><author>GreatJames</author><pubDate>Sat, 05 Sep 2020 09:30:10 +0800</pubDate><description><![CDATA[输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]

返回 true 。
示例 2:
给定二叉树 [1,2,2,3,3,null,null,4,4]

返回 false 。
题解思路
若左右子树的深度差的绝对值小于等于1，则返回当前节点的深度
若左右子树的深度差的绝对之后大于1，则返回-1
实现代码
class Solution {
    public bo]]></description><category></category></item><item><title><![CDATA[（数组）6. 无序数组中找出第K大的元素]]></title><link>https://blog.csdn.net/GreatJames/article/details/108413425</link><guid>https://blog.csdn.net/GreatJames/article/details/108413425</guid><author>GreatJames</author><pubDate>Fri, 04 Sep 2020 23:52:36 +0800</pubDate><description><![CDATA[在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
题解思路
每次切分操作总能排定一个元素，还能够知道这个元素它最终所在的位置，这样每经过一次 partition（切分）操作就能缩小搜索的范围
实现代码
public class Solution {
    public ]]></description><category></category></item><item><title><![CDATA[（数组）8. 快速排序]]></title><link>https://blog.csdn.net/GreatJames/article/details/108383011</link><guid>https://blog.csdn.net/GreatJames/article/details/108383011</guid><author>GreatJames</author><pubDate>Thu, 03 Sep 2020 14:56:59 +0800</pubDate><description><![CDATA[题解思路
先对二维数组按区间左端点大小排序，然后依次入栈
若栈内区间右端点小于当前区间左端点，则两个区间无重叠部分，直接将当前区间入栈
若栈内区间右端点大于当前区间左端点，则说明两区间存在重叠部分，更新栈内区间右端点值，取最大
实现代码
public static void quickSort(int[] array) {
    int len;
    if(array == null
            || (len = array.length) == 0
            || len]]></description><category></category></item><item><title><![CDATA[（数组）2. 合并区间（leedcode.56）（快手）]]></title><link>https://blog.csdn.net/GreatJames/article/details/108379623</link><guid>https://blog.csdn.net/GreatJames/article/details/108379623</guid><author>GreatJames</author><pubDate>Thu, 03 Sep 2020 11:48:02 +0800</pubDate><description><![CDATA[给出一个区间的集合，请合并所有重叠的区间。
示例 1:
输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2:
输入: intervals = [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
题解思路
先对二维数组按区间左端点大小排序，然后依次入栈
若栈内区间右端点小]]></description><category></category></item><item><title><![CDATA[（数组）15. 三数之和]]></title><link>https://blog.csdn.net/GreatJames/article/details/108378420</link><guid>https://blog.csdn.net/GreatJames/article/details/108378420</guid><author>GreatJames</author><pubDate>Thu, 03 Sep 2020 11:05:57 +0800</pubDate><description><![CDATA[给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
题解思路
首先对数组进行排序，排序后固定一个数 nums[i]，再使用左右指针指向 nums[i]后面的两端，数字分别为 nums[L] 和 nu]]></description><category></category></item></channel></rss>