<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[shichap的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/shichap</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; shichap]]></copyright><item><title><![CDATA[多叉查找树和红黑树]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108973721</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108973721</guid><author>shichap</author><pubDate>Fri, 09 Oct 2020 10:13:34 +0800</pubDate><description><![CDATA[多叉查找树和红黑树

上图是一个二叉查找树

二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)， 就存在如下问题:
问题1：在构建二叉树时，需要多次进行i/o操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响
问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度.

解决的方法可以使用多叉树
2-3树，2-3-4树就是多叉树，多叉树通过重新组织节点，减少树的高度，能对二叉树进行优化。
二叉树和B树


如图B树通过重新组织节点， 降低了]]></description><category></category></item><item><title><![CDATA[堆和优先队列]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108972795</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108972795</guid><author>shichap</author><pubDate>Fri, 09 Oct 2020 09:29:03 +0800</pubDate><description><![CDATA[优先队列

1.1优先队列的底层实现
根据优先队列的特点 可以使用二叉堆作为优先队列的底层实现
接下来主要回顾对的特点
堆
2.1 堆的分类

堆的一个重要的性质就是 任意节点的值总是&gt;=子节点的值或&lt;=子节点的值

2.2 堆的接口设计

2.4 二叉堆

二叉堆元素的添加和删除

向堆中添加元素siftup
向堆中删除元素siftdown



public class MaxHeap&lt;E extends Comparable&lt;E&gt;&gt; {

    private A]]></description><category></category></item><item><title><![CDATA[队列的实现]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108972291</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108972291</guid><author>shichap</author><pubDate>Fri, 09 Oct 2020 08:56:26 +0800</pubDate><description><![CDATA[队列
1.1队列的接口设计

1.2队列的底层实现


动态数组


链表
优先使用双向链表


1.3 双端队列

1.4 循环队列

循环队列的实现
public class LoopQueue&lt;E&gt; implements Queue&lt;E&gt; {

    private E[] data;
    private int front, tail;
    private int size;  

    public LoopQueue(int capacity){
      ]]></description><category></category></item><item><title><![CDATA[贪心算法总结]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108946668</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108946668</guid><author>shichap</author><pubDate>Fri, 09 Oct 2020 08:43:47 +0800</pubDate><description><![CDATA[[55. 跳跃游戏]
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。

示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。]]></description><category></category></item><item><title><![CDATA[动态规划 算法总结]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108946667</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108946667</guid><author>shichap</author><pubDate>Fri, 09 Oct 2020 08:43:20 +0800</pubDate><description><![CDATA[[122. 买卖股票的最佳时机 II]
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后，在第 4 天（股]]></description><category></category></item><item><title><![CDATA[深度优先 算法总结]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108926334</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108926334</guid><author>shichap</author><pubDate>Mon, 05 Oct 2020 17:20:11 +0800</pubDate><description><![CDATA[文章目录[98. 验证二叉搜索树]解题思路 dfs
[98. 验证二叉搜索树]
给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入:
2
/ 
1   3
输出: true
示例 2:
输入:
5
/ 
1   4
/ 
3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但]]></description><category></category></item><item><title><![CDATA[二叉树 专题]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108925326</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108925326</guid><author>shichap</author><pubDate>Mon, 05 Oct 2020 06:37:49 +0800</pubDate><description><![CDATA[94 二叉树的中序遍历
给定一个二叉树，返回它的中序 遍历。
示例:
输入: [1,null,2,3]
1

2
/
3
输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
解题方法
迭代
class Solution {
    public List&lt;Integer&gt; inorderTraversal(TreeNode root) {
        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();
        ]]></description><category></category></item><item><title><![CDATA[104. 二叉树的最大深度]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916384</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916384</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 09:28:37 +0800</pubDate><description><![CDATA[104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3

/ 
9  20
/  
15   7
返回它的最大深度 3 。
class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null)
            return 0;
  ]]></description><category></category></item><item><title><![CDATA[103. 二叉树的锯齿形层次遍历]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916361</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916361</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 09:24:16 +0800</pubDate><description><![CDATA[二叉树的锯齿形层次遍历

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
例如：
给定二叉树 [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7

返回锯齿形层次遍历如下：
[
  [3],
  [20,9],
  [15,7]
]

主要思路

用一个变量记录是在链表的头部添加还是尾部添加
当一层遍历结束后往队列中添加一个 null
当一层遍历结束之后 .]]></description><category></category></item><item><title><![CDATA[剑指 Offer 40. 最小的k个数 快排 堆]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916111</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916111</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 08:40:06 +0800</pubDate><description><![CDATA[剑指 Offer 40. 最小的k个数
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

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

限制：

0 &lt;= k &lt;= arr.length &lt;= 10000
0 &lt;= arr[i] &lt;= 10000

解题思路 优]]></description><category></category></item><item><title><![CDATA[148. 排序链表]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916103</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916103</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 08:36:14 +0800</pubDate><description><![CDATA[148. 排序链表
在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。
示例 1:
输入: 4-&gt;2-&gt;1-&gt;3
输出: 1-&gt;2-&gt;3-&gt;4

示例 2:
输入: -1-&gt;5-&gt;3-&gt;4-&gt;0
输出: -1-&gt;0-&gt;3-&gt;4-&gt;5

class Solution {
    // 解题思路归并排序
    public ListNode sortList(ListNode head) {
     ]]></description><category></category></item><item><title><![CDATA[994. 腐烂的橘子]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916092</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916092</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 08:33:46 +0800</pubDate><description><![CDATA[994. 腐烂的橘子
难度中等267收藏分享切换为英文接收动态反馈
在给定的网格中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。

每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。
返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。
示例 1：

输入：[[2,1,1],[1,1,0],[0,1,1]]
输出：4

示例 2：
输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-]]></description><category></category></item><item><title><![CDATA[200 岛屿的数量]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916084</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916084</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 08:31:26 +0800</pubDate><description><![CDATA[200 岛屿的数量
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1:
输入:
[
[‘1’,‘1’,‘1’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘0’,‘0’]
]
输出: 1
示例 2:
输入:
[
[‘1’,‘1’,‘0’,‘0’,‘]]></description><category></category></item><item><title><![CDATA[leetcode 111 二叉树的最小深度]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916070</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916070</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 08:25:22 +0800</pubDate><description><![CDATA[111. 二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度  2.
解题思路 递归
class Solution {
    public int minDepth(TreeNode root) {
        if(root==null]]></description><category></category></item><item><title><![CDATA[102. 二叉树的层序遍历]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916067</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916067</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 08:24:12 +0800</pubDate><description><![CDATA[102. 二叉树的层序遍历
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：
二叉树：[3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]

class Solution {
    public List&lt;List&lt;Integer&gt;&gt; levelOrder(TreeNode]]></description><category></category></item><item><title><![CDATA[101. 对称二叉树]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916047</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916047</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 08:18:59 +0800</pubDate><description><![CDATA[101. 对称二叉树
难度简单1054收藏分享切换为英文接收动态反馈
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [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

进阶：
你可以运用递归和迭代两种方法解决这个问题吗？
class Solution {
    pu]]></description><category></category></item><item><title><![CDATA[leetcode 94 二叉树的中序遍历 递归和迭代]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/108916034</link><guid>https://blog.youkuaiyun.com/shichap/article/details/108916034</guid><author>shichap</author><pubDate>Sun, 04 Oct 2020 08:15:28 +0800</pubDate><description><![CDATA[给定一个二叉树，返回它的中序 遍历。
示例:
输入: [1,null,2,3]
1

2
/
3
输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
迭代
class Solution {
    public List&lt;Integer&gt; inorderTraversal(TreeNode root) {
        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();
        Stack&lt;TreeNode]]></description><category></category></item><item><title><![CDATA[leetcode 64 最小路径 动态规划]]></title><link>https://blog.youkuaiyun.com/shichap/article/details/107915045</link><guid>https://blog.youkuaiyun.com/shichap/article/details/107915045</guid><author>shichap</author><pubDate>Mon, 10 Aug 2020 16:02:00 +0800</pubDate><description><![CDATA[动态规划的解题
class Solution {
    public int minPathSum(int[][] grid) {
        if(grid==null || grid.length==0|| grid[0].length==0){
            return 0;
        }
        int rows = grid.length;
        int columns=grid[0].length;
        int[][] dp = new in]]></description><category></category></item></channel></rss>