search.xml

<?xml version="1.0" encoding="utf-8"?>
<search>
  <entry>
    <title><![CDATA[类的加载机制]]></title>
    <url>%2F2019%2F05%2F31%2F%E7%B1%BB%E7%9A%84%E5%8A%A0%E8%BD%BD%E6%9C%BA%E5%88%B6%2F</url>
    <content type="text"><![CDATA[把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型。 类的生命周期加载，验证，准备，解析，初始化，使用和卸载。其中验证，准备，解析3个部分统称为连接。 加载，验证，准备，初始化，卸载这5个阶段的顺序是确定的，而解析阶段则不一定：它在某些情况下可以在初始化完成后在开始，这是为了支持Java语言的运行时绑定。 何时触发初始化 为一个类型创建一个新的对象实例时（比如new、反射、序列化） 调用一个类型的静态方法时（即在字节码中执行invokestatic指令） 调用一个类型或接口的静态字段，或者对这些静态字段执行赋值操作时（即在字节码中，执行getstatic或者putstatic指令），不过用final修饰的静态字段除外，它被初始化为一个编译时常量表达式 使用java.lang.reflect包的方法对类进行反射调用的时候。 当初始化一个类的时候，发现其父类还没有进行过初始化，则需要先出发父类的初始化。 JVM启动包含main方法的启动类时。被动引用 子类调用父类的静态变量，子类不会被初始化，只有父类被初始化。对于静态字段，只有直接定义这个字段的类才会被初始化. 通过数组定义来引用类，不会触发类的初始化 访问类的常量，不会初始化类类的加载过程加载加载阶段是类加载过程的第一个阶段。在这个阶段，JVM 的主要目的是将字节码从各个位置（网络、磁盘等）转化为二进制字节流加载到内存中，接着会为这个类在 JVM 的方法区创建一个对应的 Class 对象，这个 Class 对象就是这个类各种数据的访问入口。验证是连接阶段的第一步，目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。 包含四个阶段的校验动作 文件格式验证验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。 元数据验证对类的元数据信息进行语义校验，是否不存在不符合Java语言规范的元数据信息 字节码验证最复杂的一个阶段，主要目的是通过数据流和控制流分析，确定程序语义是合法的，符合逻辑的。对类的方法体进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的事件。 符号引用验证最后一个阶段的校验发生在虚拟机将符号引用转换为直接引用的时候，这个转换动作将在连接的第三个阶段——解析阶段中发生。 符号验证的目的是确保解析动作能正常进行。 准备准备阶段是为类的静态变量分配内存并将其初始化为默认值，这些内存都将在方法区中进行分配。准备阶段不分配类中的实例变量的内存，实例变量将会在对象实例化时随着对象一起分配在Java堆中。 12//在准备阶段value初始值为0。在初始化阶段才会变为123。public static int value=123; “特殊情况”下，如果类字段的字段属性表中存在ConstantValue(说明)属性，那么在准备阶段变量的值就会被初始化为ConstantValue属性所指定的值。 解析虚拟机将常量池内的符号引用替换为直接引用的过程。“动态解析”的含义就是必须等到程序实际运行到这条指令的时候，解析动作才能进行。相对的，其余可触发解析的指令都是“静态”的，可以在刚刚完成加载阶段，还没有开始执行代码时就进行解析。 初始化类加载过程中的最后一步。初始化阶段是执行类构造器()方法的过程。 ()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块中的语句合并产生的。 ()与类的构造函数不同，它不需要显示地调用父类构造器，虚拟机会保证在子类的()方法执行之前，父类的()方法已经执行完毕。 简单地说，初始化就是对类变量进行赋值及执行静态代码块。 使用当 JVM 完成初始化阶段之后，JVM 便开始从入口方法开始执行用户的程序代码。这个阶段也只是了解一下就可以。 卸载当 JVM 完成初始化阶段之后，JVM 便开始从入口方法开始执行用户的程序代码。这个阶段也只是了解一下就可以。 类加载器Java中的类加载器 启动类加载器（Bootstrap ClassLoader）： 由C++语言实现（针对HotSpot）,负责将存放在\lib目录或-Xbootclasspath参数指定的路径中的类库加载到内存中，即负责加载Java的核心类。 其他类加载器： 由Java语言实现，继承自抽象类ClassLoader。如： 扩展类加载器（Extension ClassLoader）： 负责加载\lib\ext目录或java.ext.dirs系统变量指定的路径中的所有类库，即负责加载Java扩展的核心类之外的类。 应用程序类加载器（Application ClassLoader）： 负责加载用户类路径（classpath）上的指定类库，我们可以直接使用这个类加载器，通过ClassLoader.getSystemClassLoader()方法直接获取。一般情况，如果我们没有自定义类加载器默认就是用这个加载器。 Android中的类加载器 Android中的ClassLoader类型也可分为系统ClassLoader和自定义ClassLoader BootClassLoader：Android系统启动时会使用BootClassLoader来预加载常用类，与Java中的Bootstrap ClassLoader不同的是，它并不是由C/C++代码实现，而是由Java实现的。BootClassLoader是ClassLoader的一个内部类。 PathClassLoader：全名是dalvik/system.PathClassLoader，可以加载已经安装的Apk，也就是/data/app/package 下的apk文件，也可以加载/vendor/lib, /system/lib下的nativeLibrary。 DexClassLoader：全名是dalvik/system.DexClassLoader，可以加载一个未安装的apk文件。 PathClassLoader和DexClasLoader都是继承自 dalviksystem.BaseDexClassLoader，它们的类加载逻辑全部写在BaseDexClassLoader中。 双亲委派模型双亲委派模型的工作流程是：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把请求委托给父加载器去完成，依次向上，因此，所有的类加载请求最终都应该被传递到顶层的启动类加载器中，只有当父加载器在它的搜索范围中没有找到所需的类时，即无法完成该加载，子加载器才会尝试自己去加载该类。 这样的好处是不同层次的类加载器具有不同优先级，比如所有Java对象的超级父类java.lang.Object，位于rt.jar，无论哪个类加载器加载该类，最终都是由启动类加载器进行加载，保证安全。即使用户自己编写一个java.lang.Object类并放入程序中，虽能正常编译，但不会被加载运行，保证不会出现混乱。]]></content>
      <categories>
        <category>Java</category>
      </categories>
      <tags>
        <tag>基础</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[HashMap源码]]></title>
    <url>%2F2019%2F05%2F20%2FHashMap%E6%BA%90%E7%A0%81%2F</url>
    <content type="text"><![CDATA[HashMap是由数组和链表组合构成的数据结构，Java8中链表长度超过8时会把长度超过8的链表转化成红黑树；存取时都会根据键值计算出“类别”(hashCode)，再根据”类别”定位到数组中的位置并执行操作。 HashMap 的工作原理HashMap 是基于 hashing 的原理我们使用 put(key, value) 存储对象到 HashMap 中，使用 get(key) 从 HashMap 中获取对象。当我们给 put() 方法传递键和值时，我们先对键调用 hashCode() 方法，计算并返回的 hashCode 是用于找到 Map 数组的 bucket 位置来储存 Node 对象。这里关键点在于指出，HashMap 是在 bucket 中储存键对象和值对象，作为Map.Node 。 put 过程（JDK1.8） 对 Key 求 Hash 值，然后再计算下标 如果没有碰撞，直接放入桶中（碰撞的意思是计算得到的 Hash 值相同，需要放到同一个 bucket 中） 如果碰撞了，以链表的方式链接到后面 如果链表长度超过阀值（TREEIFY THRESHOLD==8），就把链表转成红黑树，链表长度低于6，就把红黑树转回链表 如果节点已经存在就替换旧值 如果桶满了（容量16*加载因子0.75），就需要 resize（扩容2倍后重排） JDK7流程，如图 JDK8流程，如图 7和8对比1.发生hash冲突时，Java7会在链表头部插入，Java8会在链表尾部插入2.扩容后转移数据，Java7转移前后链表顺序会倒置，Java8还是保持原来的顺序3.引入红黑树的Java8大程度得优化了HashMap的性能 线程不安全HashMap在put的时候，插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是rehash，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash值相同，可能出现同时在同一数组下用链表表示，造成闭环，导致在get时会出现死循环，所以HashMap是线程不安全的。 参考文章https://juejin.im/post/5a23f82ff265da432003109b#heading-7http://www.importnew.com/31278.htmlhttps://blog.csdn.net/zaimeiyeshicengjing/article/details/81589953]]></content>
      <categories>
        <category>Java</category>
      </categories>
      <tags>
        <tag>基础</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Retrofit源码]]></title>
    <url>%2F2019%2F05%2F09%2FRetrofit%20%E6%BA%90%E7%A0%81%2F</url>
    <content type="text"><![CDATA[Retrofit就是一个网络请求框架的封装，底层的网络请求默认使用的Okhttp，本身只是简化了用户网络请求的参数配置等，还能与Rxjava相结合，使用起来更加简洁方便。 下图是请求的流程图： 请求步骤 通过Builder模式，添加所需的baseUrl，callFactory(实际就是OkHttpClient)，converterFactories(将服务器返回数据转为所需的数据，例如bean)和callAdapterFactories（根据需要是否创建call转换器，例如RxJava）,创建Retrofit实例 定义网络请求接口，并为接口中的方法添加注解 通过动态代理为请求接口创建实例 通过loadServiceMethod()方法创建提供call转换器，数据转换器和发起网络请求必须的参数(前两者实际为Retrofit类创建) 构建OkHttpCall 发起网络请求（实际执行是由OkHttp来做具体网络请求工作） 运用到的设计模式外观模式：核心类就是Retrofit，我们只管配置Retrofit，然后做请求。剩下的事情就跟上层无关了，只需要等待回调。这样大大降低了系统的耦合度； Builder模式：构建Retrofit所需的必须参数； 动态代理：动态代理就是拦截调用的那个方法，在方法前后来做一些操作。为网络请求接口动态创建实例； 工厂模式：通过工厂创建CallAdapter，Converter； 适配器模式：根据不同类型返回与之匹配的操作类，例如如果与RxJava配合就需要返回RxJava2CallAdapterFactory，不需要默认是ExecutorCallAdapterFactory； 装饰模式：跟静态代理类似，例如可以ExecutorCallAdapterFactory装饰类，实际操作者是OKHttpCall； 参考文章https://www.jianshu.com/p/fb8d21978e38]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>框架</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[矩阵中的最长递增路径]]></title>
    <url>%2F2019%2F05%2F06%2F%E7%9F%A9%E9%98%B5%E4%B8%AD%E7%9A%84%E6%9C%80%E9%95%BF%E9%80%92%E5%A2%9E%E8%B7%AF%E5%BE%84%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：329 给定一个整数矩阵，找出最长递增路径的长度。对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。 示例 1: 12345678输入: nums = [ [9,9,4], [6,6,8], [2,1,1]] 输出: 4 解释: 最长递增路径为 [1, 2, 6, 9]。 示例 2: 12345678输入: nums = [ [3,4,5], [3,2,6], [2,2,1]] 输出: 4 解释: 最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。 我的解答 解题思路：记忆化搜索,获取递增序列，记录每个点能达到的最长路径，遍历完矩阵得到最长递增路径 123456789101112131415161718192021222324252627282930313233343536373839class Solution &#123; int[][] visited; int m, n; public int longestIncreasingPath(int[][] matrix) &#123; if (matrix.length == 0 || matrix[0].length == 0) return 0; m = matrix.length; n = matrix[0].length; int res = 1; visited = new int[m][n]; for (int i = 0; i &lt; m; i++)&#123; for (int j = 0; j &lt; n; j++)&#123; if (visited[i][j] != 0) continue; res = Math.max(res, dfs(matrix, i, j, Integer.MIN_VALUE)); &#125; &#125; return res; &#125; public int dfs(int[][] matrix, int i, int j, int oldVal)&#123; // 检查当前坐标是否合法，是否递增 if (i &lt; 0 || i &gt;= m || j &lt; 0 || j &gt;= n || matrix[i][j] &lt;= oldVal) return 0; // 检查当前坐标是否已被访问 if (visited[i][j] == 0)&#123; // 对四个方向递归调用dfs int curVal = matrix[i][j]; int up = dfs(matrix, i + 1, j, curVal); int down = dfs(matrix, i - 1, j, curVal); int right = dfs(matrix, i, j + 1, curVal); int left = dfs(matrix, i, j - 1, curVal); // 设置当前坐标的最长递增路径 visited[i][j] = 1 + Math.max(Math.max(up, down), Math.max(right, left)); &#125; return visited[i][j]; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>动态规划</tag>
        <tag>困难</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[零钱兑换]]></title>
    <url>%2F2019%2F05%2F05%2F%E9%9B%B6%E9%92%B1%E5%85%91%E6%8D%A2%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：322 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。 示例 1: 123输入: coins = [1, 2, 5], amount = 11输出: 3 解释: 11 = 5 + 5 + 1 示例 2: 12输入: coins = [2], amount = 3输出: -1 我的解答 解题思路：使用动态规划，遍历amount，记录当i元时最少需要的硬币数，如果i-coins[j]下标的值为-1，证明没有这种硬币组合，反之就是dp[i] = dp[i-coins[j]]+1;遍历完dp[amount] 就是最后的结果 123456789101112131415public static int coinChange(int[] coins, int amount) &#123; int[] dp = new int[amount+1]; for (int i=1;i&lt;=amount;i++)&#123; int min = Integer.MAX_VALUE; for (int j=0;j&lt;coins.length;j++)&#123; int value = i-coins[j]; if (value&gt;=0 &amp;&amp; dp[value] != -1)&#123; min = Math.min(min,dp[value]+1); &#125; &#125; min = min==Integer.MAX_VALUE ? -1 : min; dp[i] = min; &#125; return dp[amount];&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[和为K的子数组]]></title>
    <url>%2F2019%2F04%2F30%2F%E5%92%8C%E4%B8%BAK%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：560 给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。 示例 1 : 12输入:nums = [1,1,1], k = 2输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。 说明 : 数组的长度为 [1, 20,000]。 数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。 我的解答 解题思路：通过map来记录，key为下标0到i的和，如果sum[i]-sum[j] = k,说明在[i,j]区间的和满足于k，map的value表示满足k的个数 12345678910111213public int subarraySum(int[] nums, int k) &#123; Map&lt;Integer, Integer&gt; map = new HashMap&lt;&gt;(); map.put(0, 1); int sum = 0, ret = 0; for(int i = 0; i &lt; nums.length; ++i) &#123; sum += nums[i]; if(map.containsKey(sum-k)) ret += map.get(sum-k); map.put(sum, map.getOrDefault(sum, 0)+1); &#125; return ret;&#125; 延伸一道阿里的面试题 给出一个正整数数组和一个数，返回一个数组走那个连续元素的和等于所给数的子数组 加分时间复杂度为2n 我的解答 解法一(暴力法) 123456789101112131415161718192021222324public static int[] continuousSum(int[] nums, int k)&#123; int sum = 0; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); boolean isFind = false; for (int i=0;i&lt;nums.length;i++)&#123; sum = 0; for (int j=i;j&lt;nums.length;j++)&#123; sum +=nums[j]; list.add(nums[j]); if (sum == k)&#123; isFind = true; break; &#125; &#125; if (isFind) break; list.clear(); &#125; int[] arr = new int[list.size()]; for (int i=0;i&lt;list.size();i++)&#123; arr[i] = list.get(i); &#125; return arr;&#125; 解法二 解题思路：遍历数组nums，通过不断累加数组元素sum，如果sum = k,结束遍历记录当前的下标值end，如果sum&gt;k,删除sum的头部下标值start；最后通过start和end的来获取nums的区间值 12345678910111213141516171819public static int[] continuousSum(int[] nums, int k)&#123; int sum = 0, start = 0, end = 0; for(int i = 0; i &lt; nums.length; ++i) &#123; sum += nums[i]; end = i; if(sum == k)&#123; end = i; break; &#125;else if (sum &gt; k)&#123; sum = sum - nums[start++]; &#125; &#125; int[] arr = new int[end - start]; for (int i=start;i&lt;end;i++)&#123; arr[i-start] = nums[i+1]; &#125; return arr;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数组</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[最长连续序列]]></title>
    <url>%2F2019%2F04%2F29%2F%E6%9C%80%E9%95%BF%E4%B8%8A%E5%8D%87%E5%AD%90%E5%BA%8F%E5%88%97%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：300 给定一个无序的整数数组，找到其中最长上升子序列的长度。 示例: 123输入: [10,9,2,5,3,7,101,18]输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 说明: 可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。 你算法的时间复杂度应该为 O(n**2) 。 进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗? 我的解答 解法一 解题思路：通过动态规划，通过dp数组不断记录在每个数组下标时，子序列最大的上升长度，最后在比较dp数组中最大的子序列长度 1234567891011121314public static int lengthOfLIS(int[] nums) &#123; int[] dp = new int[nums.length]; int max = 0; for (int i=0;i&lt;nums.length;i++)&#123; dp[i] = 1; for (int j=0;j&lt;i;j++)&#123; if (nums[j]&lt;nums[i])&#123; dp[i] = Math.max(dp[i],dp[j]+1); &#125; &#125; max = Math.max(max,dp[i]); &#125; return max;&#125; 解法二 解题思路：通过二分查找，从nums第一个元素添加到新数组dp中，然后不断和nums的之后元素进行比较，只要比dp数组中元素大，添加进来，增加上升序列的result长度，如果比dp数组中元素小，替换dp中的元素，遍历完nums数组，result+1就是nums中最长上升子序列的长度 1234567891011121314151617181920212223242526public static int lengthOfLIS(int[] nums) &#123; if(nums.length==0)&#123; return 0; &#125; int result=0; int[] dp=new int[nums.length]; dp[0]=nums[0]; for(int i=1;i&lt;nums.length;i++)&#123; if(nums[i]&gt;dp[result])&#123; dp[++result]=nums[i]; &#125;else&#123; int left=0; int right=result; while(left&lt;right)&#123; int mid=(left+right)/2; if(nums[i]&lt;=dp[mid])&#123; right=mid; &#125;else&#123; left=mid+1; &#125; &#125; dp[right]=nums[i]; &#125; &#125; return result+1;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[完全平方数]]></title>
    <url>%2F2019%2F04%2F28%2F%E5%AE%8C%E5%85%A8%E5%B9%B3%E6%96%B9%E6%95%B0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：279 给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。 示例 1: 123输入: n = 12输出: 3 解释: 12 = 4 + 4 + 4. 示例 2: 123输入: n = 13输出: 2解释: 13 = 4 + 9. 我的解答 解法一 解题思路：四平方定理： 任何一个正整数都可以表示成不超过四个整数的平方之和。 推论：满足四数平方和定理的数n（四个整数的情况），必定满足 n=4^a(8b+7) 12345678910111213141516171819202122public int numSquares(int n) &#123; //先根据上面提到的公式来缩小n while (n % 4 == 0)&#123; n /= 4; &#125; if (n % 8 == 7)&#123;//满足四平方和定理 return 4; &#125; //在判断缩小后的数是否可以由一个数的平方或者两个数平方的和组成 int a = 0; while(a * a &lt; n) &#123; int b = (int) Math.sqrt(n - a * a); if(a * a + b * b == n) &#123; if(a == 0 &amp;&amp; b == 0) return 0; else if(a != 0 &amp;&amp; b != 0) return 2; else return 1; &#125; a = a + 1; &#125; //如果不是返回3 return 3;&#125; 解法二：动态规划 解题思路：采用动态规划实现。用 dp[i] 数组存储第 i 个数的完美平方数。递推式为：dp[i] = Math.max(dp[j] + dp[i-j], dp[i]，认为 i 的完全平方数是从和为 i 的两个完全平方数 dp[j] 和 dp[i-j]之和，然后从中取最小 123456789101112131415public int numSquares(int n) &#123; int[] dp = new int[n+1]; Arrays.fill(dp, Integer.MAX_VALUE); dp[0] = 0; for (int i=1;i&lt;=n;i++)&#123; int min = Integer.MAX_VALUE; int j = 1; while(i - j*j &gt;= 0) &#123; min = Math.min(min, dp[i - j*j] + 1); j++; &#125; dp[i] = min; &#125; return dp[n];&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[最长连续序列]]></title>
    <url>%2F2019%2F04%2F26%2F%E6%9C%80%E9%95%BF%E8%BF%9E%E7%BB%AD%E5%BA%8F%E5%88%97%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：128 给定一个未排序的整数数组，找出最长连续序列的长度。要求算法的时间复杂度为 O(n)。 示例: 123输入: [100, 4, 200, 1, 3, 2]输出: 4解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。 我的解答 解题思路：先将数组进行从小到大排序，然后遍历数组，如果前后两个数差值是1，tmp++；如果差值大于1，比较得出之前最大连续长度，tmp归0，重新计算；遍历完，在比较得出数组中最大连续长度 12345678910111213141516public static int longestConsecutive(int[] nums) &#123; if (nums.length &lt;= 1) return nums.length; Arrays.sort(nums); int length = 0,tmp = 0; for (int i=1;i&lt;nums.length;i++)&#123; int diff = nums[i]-nums[i-1]; if(diff == 1)&#123; tmp++; &#125;else if (diff&gt;1)&#123; length = Math.max(length,tmp+1); tmp = 0; &#125; &#125; length = Math.max(length,tmp+1); return length;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>动态规划</tag>
        <tag>困难</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[二叉树中的最大路径和]]></title>
    <url>%2F2019%2F04%2F25%2F%E4%BA%8C%E5%8F%89%E6%A0%91%E4%B8%AD%E7%9A%84%E6%9C%80%E5%A4%A7%E8%B7%AF%E5%BE%84%E5%92%8C%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：124 给定一个非空二叉树，返回其最大路径和。本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。 示例 1: 1234567输入: [1,2,3] 1 / \ 2 3输出: 6 示例 2: 123456789输入: [-10,9,20,null,null,15,7] -10 / \ 9 20 / \ 15 7输出: 42 我的解答 解题思路：对于任意一个节点, 有4种情况:1.该节点本身(左右子树的路径为负)2.该节点+左子树路径3.该节点+右子树路径4.该节点+左子树路径+右子树路径其中1，2，3都可以作为子树路径和向上延伸，而4则不行 123456789101112131415private static int ret = Integer.MIN_VALUE;public static int maxPathSum(TreeNode root) &#123; ret = Integer.MIN_VALUE; getMax(root); return ret;&#125;private static int getMax(TreeNode r) &#123; if(r == null) return 0; // 如果子树路径和为负则应当置0表示最大路径不包含子树 int left = Math.max(0, getMax(r.left)); int right = Math.max(0, getMax(r.right)); // 判断在该节点包含左右子树的路径和是否大于当前最大路径和 ret = Math.max(ret, r.val + left + right); return Math.max(left, right) + r.val;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>树</tag>
        <tag>困难</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[至少有K个重复字符的最长子串]]></title>
    <url>%2F2019%2F04%2F24%2F%E8%87%B3%E5%B0%91%E6%9C%89K%E4%B8%AA%E9%87%8D%E5%A4%8D%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E9%95%BF%E5%AD%90%E4%B8%B2%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：395 找到给定字符串（由小写字符组成）中的最长子串 T ， 要求 T 中的每一字符出现次数都不少于 k 。输出 T 的长度。 示例 1:1234567输入:s = &quot;aaabb&quot;, k = 3输出:3最长子串为 &quot;aaa&quot; ，其中 &apos;a&apos; 重复了 3 次。 示例 2:1234567输入:s = &quot;ababbc&quot;, k = 2输出:5最长子串为 &quot;ababb&quot; ，其中 &apos;a&apos; 重复了 2 次， &apos;b&apos; 重复了 3 次。 我的解答 解题思路：使用两个指针left、right，和小写字母计数器统计字符段中各个字符出现的次数。如果中间有出现次数小于k的字符，然后调整当前的left、right指针，再遍历一遍修正后的字符串，最后 12345678910111213141516171819202122232425262728293031323334353637383940414243public static int longestSubstring(String s, int k) &#123; if (s.length() &lt; k) &#123; return 0; &#125; else if (k == 1) &#123; return s.length(); &#125; return longestSubstring(s, 0, s.length() - 1, k);&#125;private static int longestSubstring(String s, int left, int right, int k) &#123; if (right - left + 1 &lt; k) &#123; return 0; &#125; int[] counts = new int[26]; for (int i = left; i &lt;= right; i++) &#123; counts[s.charAt(i) - &apos;a&apos;]++; &#125; int last = left, maxLength = 0; boolean isSplit = false; for (int i = left; i &lt;= right; i++) &#123; if (isSplit(counts, s.charAt(i), k)) &#123; maxLength = Math.max(maxLength, longestSubstring(s, last, i - 1, k)); last = i + 1; isSplit = true; &#125; else if (i == right &amp;&amp; isSplit) &#123; maxLength = Math.max(maxLength, longestSubstring(s, last, right, k)); &#125; &#125; if (isSplit) &#123; return maxLength; &#125; else &#123; return right - left + 1; &#125;&#125;private static boolean isSplit(int[] counts, char c, int k) &#123; int i = c - &apos;a&apos;; return counts[i] &gt; 0 &amp;&amp; counts[i] &lt; k;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[OkHttp源码]]></title>
    <url>%2F2019%2F04%2F23%2FOkHttp%E6%BA%90%E7%A0%81%2F</url>
    <content type="text"><![CDATA[OKHttp是Square处理网络请求的开源框架。 分析OkHttp源码，可以从发起一次完成请求开始： 下图是一次请求调用过程： 一次请求过程 创建一个Request，包含请求过程所需的url，method、headers以及body； OkHttpClient通过Request的对象，创建Call对象（实际是RealCall）； 同步请求调用execute()，这时Dispatcher会将Call加入到双端队列runningSyncCalls； 异步请求调用enqueue(),回创建AsyncCal(实际是Runnable),Dispatche会将Call放到线程池中； 不管是异步还是同步，都会调用getResponseWithInterceptorChain()，这里会把 client 中的拦截器、重连拦截器、桥拦截器、缓存拦截器、网络连接拦截器和服务器请求拦截器等依次加入到列表中。然后，我们用这个列表创建了一个拦截器链。这里使用了责任链设计模式，每当一个拦截器执行完毕之后会调用下一个拦截器或者不调用并返回结果。显然，我们最终拿到的响应就是这个链条执行之后返回的结果。当我们自定义一个拦截器的时候，也会被加入到这个拦截器链条里； 执行完请求，会调用client.dispatcher().finished(this)，将此次请求从队列中移除。 运用到的设计模式： 外观模式 : OKHttpClient 里面组合了很多的类对象。其实是将OKHttp的很多功能模块，全部包装进这个类中，让这个类单独提供对外的API，这种设计叫做外观模式（外观模式：隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口） Builder模式 : OkHttpClient 比较复杂， 太多属性， 而且客户的组合需求多样化， 所以OKhttp使用建造者模式（Build模式：使用多个简单的对象一步一步构建成一个复杂的对象，一个 Builder 类会一步一步构造最终的对象） 工厂方法模式：Call接口提供了内部接口Factory(用于将对象的创建延迟到该工厂类的子类中进行，从而实现动态的配置，工厂方法模式。（工厂方法模式：这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。） 享元模式：在Dispatcher的线程池中，所用到了享元模式，一个不限容量的线程池 ， 线程空闲时存活时间为 60 秒。线程池实现了对象复用，降低线程创建开销，从设计模式上来讲，使用了享元模式。（享元模式：尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象，主要用于减少创建对象的数量，以减少内存占用和提高性能） 责任链模式：在okhttp中的拦截器模块，执行过程用到。OkHttp3 的拦截器链中， 内置了5个默认的拦截器，分别用于重试、请求对象转换、缓存、链接、网络读写（责任链模式：为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。） 策略模式 ：CacheInterceptor 实现了数据的选择策略， 来自网络还是来自本地？ 这个场景也是比较契合策略模式场景， CacheInterceptor 需要一个策略提供者提供它一个策略， CacheInterceptor 根据这个策略去选择走网络数据还是本地缓存。缓存的策略过程： 请求头包含 “If-Modified-Since” 或 “If-None-Match” 暂时不走缓存 客户端通过 cacheControl 指定了无缓存，不走缓存 客户端通过 cacheControl 指定了缓存，则看缓存过期时间，符合要求走缓存。 如果走了网络请求，响应状态码为 304（只有客户端请求头包含 “If-Modified-Since” 或 “If-None-Match” ，服务器数据没变化的话会返回304状态码，不会返回响应内容）， 表示客户端继续用缓存。 各个拦截器的作用 RetryAndFollowUpInterceptor 主要用来当请求失败的时候进行重试，以及在需要的情况下进行重定向。 BridgeInterceptor 用于从用户的请求中构建网络请求，然后使用该请求访问网络，最后从网络响应当中构建用户响应。 CacheInterceptor 根据请求的信息和缓存的信息判断缓存是否可用。如果可用，返回缓存给客户端，如果不可用继续从服务器中获取响应。 ConnectInterceptor 用来打开到指定服务器的网络连接，并交给下一个拦截器处理。这里只打开了一个网络连接，但是并没有发送请求到服务器。从服务器获取数据的逻辑交给下一级的拦截器来执行。 CallServerInterceptor 用来向服务器发起请求并获取数据。这是整个责任链的最后一个拦截器，这里没有再继续调用执行链的处理方法，而是把拿到的响应处理之后直接返回给了上一级的拦截器 参考文章https://www.androidos.net.cn/codebook/AndroidRoad/android/open-source-framework/okhttp.htmlhttps://juejin.im/post/5bc89fbc5188255c713cb8a5#heading-0https://blog.csdn.net/u012881042/article/details/79759203]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>框架</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[二叉树的序列化与反序列化]]></title>
    <url>%2F2019%2F04%2F23%2F%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%BA%8F%E5%88%97%E5%8C%96%E4%B8%8E%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：297 序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 示例: 123456789你可以将以下二叉树： 1 / \ 2 3 / \ 4 5序列化为 &quot;[1,2,3,null,null,4,5]&quot; 提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。 说明: 不要使用类的成员 / 全局 / 静态变量来存储状态，你的序列化和反序列化算法应该是无状态的。 我的解答 解题思路：序列化，通过层次遍历，将各个节点的值，用字符串拼接起来；反序列化，已知字符串格式，分割成数组，通过遍历，按照层次顺序，依次将数组的值，放到二叉树的各个节点上 12345678910111213141516171819202122232425262728293031323334353637383940414243444546public class Codec &#123; // Encodes a tree to a single string. public String serialize(TreeNode root) &#123; if (root == null) return &quot;&quot;; Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;(); queue.add(root); StringBuffer sb = new StringBuffer(); while (!queue.isEmpty())&#123; TreeNode node = queue.poll(); if (node == null)&#123; sb.append(&quot;null,&quot;); &#125;else &#123; sb.append(node.val+&quot;,&quot;); queue.add(node.left); queue.add(node.right); &#125; &#125; return sb.toString(); &#125; // Decodes your encoded data to tree. public TreeNode deserialize(String data) &#123; if (data.length() == 0) return null; String[] dataArr = data.split(&quot;,&quot;); Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;(); int index = 0; TreeNode root = new TreeNode( Integer.parseInt(dataArr[index])); queue.add(root); while (!queue.isEmpty())&#123; TreeNode node = queue.poll(); String value = dataArr[++index]; if (!value.equals(&quot;null&quot;))&#123; node.left = new TreeNode(Integer.parseInt(value)); queue.add(node.left); &#125; value = dataArr[++index]; if (!value.equals(&quot;null&quot;))&#123; node.right = new TreeNode(Integer.parseInt(value)); queue.add(node.right); &#125; &#125; return root; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>树</tag>
        <tag>困难</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[二叉树的最近公共祖先]]></title>
    <url>%2F2019%2F04%2F22%2F%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：236 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4] 示例 1: 123输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1输出: 3解释: 节点 5 和节点 1 的最近公共祖先是节点 3。 示例 2: 123输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4输出: 5解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。 说明: 所有节点的值都是唯一的。 p、q 为不同节点且均存在于给定的二叉树中。 我的解答 解题思路：LCA问题，通过递归，如果去p,q任意一个与root相匹配，那么root就是最近公共祖先。如果都不匹配，则分别递归左、右子树，如果有一个节点出现在左子树，并且另一个节点出现在右子树，则root就是最低公共祖先. 如果两个节点都出现在左子树，则说明最低公共祖先在左子树中，否则在右子树。 123456789101112131415161718public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) &#123; if (root == null) &#123; return root; &#125; if (root.val == p.val || root.val == q.val) &#123; return root; &#125; TreeNode left = lowestCommonAncestor(root.left, p, q); TreeNode right = lowestCommonAncestor(root.right, p, q); if (left != null &amp;&amp; right != null) &#123; return root; &#125; else if (left != null) &#123; return left; &#125; else if (right != null) &#123; return right; &#125; return null;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>树</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[二叉搜索树中第K小的元素]]></title>
    <url>%2F2019%2F04%2F19%2F%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%AC%ACK%E5%B0%8F%E7%9A%84%E5%85%83%E7%B4%A0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：230 给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。 说明：你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。 示例 1: 1234567输入: root = [3,1,4,null,2], k = 1 3 / \ 1 4 \ 2输出: 1 示例 2: 123456789输入: root = [5,3,6,2,4,null,null,1], k = 3 5 / \ 3 6 / \ 2 4 / 1输出: 3 进阶： 如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化 kthSmallest 函数？ 我的解答 解题思路：已知是二叉搜索树，求k个最小。通过中序遍历,从最小的元素开始计数index，当index = k时，进行赋值，得出最k个小元素值 1234567891011121314public int index = 0,value = 0;public int kthSmallest(TreeNode root, int k) &#123; travers(root,k); return value;&#125;private void travers(TreeNode root,int k) &#123; if (root == null) return; travers(root.left, k); index++; if (index == k)&#123; value = root.val; &#125; travers(root.right,k);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>树</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[常数时间插入、删除和获取随机元素]]></title>
    <url>%2F2019%2F04%2F18%2F%E5%B8%B8%E6%95%B0%E6%97%B6%E9%97%B4%E6%8F%92%E5%85%A5%E3%80%81%E5%88%A0%E9%99%A4%E5%92%8C%E8%8E%B7%E5%8F%96%E9%9A%8F%E6%9C%BA%E5%85%83%E7%B4%A0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：380 设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构。 insert(val)：当元素 val 不存在时，向集合中插入该项。 remove(val)：元素 val 存在时，从集合中移除该项。 getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。 示例 : 1234567891011121314151617181920212223// 初始化一个空的集合。RandomizedSet randomSet = new RandomizedSet();// 向集合中插入 1 。返回 true 表示 1 被成功地插入。randomSet.insert(1);// 返回 false ，表示集合中不存在 2 。randomSet.remove(2);// 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。randomSet.insert(2);// getRandom 应随机返回 1 或 2 。randomSet.getRandom();// 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。randomSet.remove(1);// 2 已在集合中，所以返回 false 。randomSet.insert(2);// 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。randomSet.getRandom(); 我的解答 解题思路：用List的来存储元素,用Map来存储元素和元素下标(加快元素的检索速度) 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556public class RandomizedSet &#123; private ArrayList&lt;Integer&gt; list; private HashMap&lt;Integer,Integer&gt; map; private Random random; /** Initialize your data structure here. */ public RandomizedSet() &#123; list = new ArrayList&lt;&gt;(); map = new HashMap&lt;&gt;(); random = new Random(); &#125; /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */ public boolean insert(int val) &#123; if (map.containsKey(val)) &#123; return false; &#125; map.put(val,list.size()); list.add(val); return true; &#125; /** Removes a value from the set. Returns true if the set contained the specified element. */ public boolean remove(int val) &#123; if (map.containsKey(val)) &#123; int index = map.get(val); //每次直接删除会导致list中的元素下标会发生变化,这里先将要删除的元 //素,用最后一个元素替换掉，再将最后一个元素删掉,达到删除的目的 if (index != list.size() - 1)&#123; int last = list.get(list.size() - 1); list.set(index,last); map.put(last,index); &#125; list.remove(list.size() - 1); map.remove(val); return true; &#125; return false; &#125; /** Get a random element from the set. */ public int getRandom() &#123; int index = random.nextInt(list.size()); return list.get(index); &#125;&#125;/** * Your RandomizedSet object will be instantiated and called as such: * RandomizedSet obj = new RandomizedSet(); * boolean param_1 = obj.insert(val); * boolean param_2 = obj.remove(val); * int param_3 = obj.getRandom(); */]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>hash</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[四数相加 II]]></title>
    <url>%2F2019%2F04%2F17%2F%E5%9B%9B%E6%95%B0%E7%9B%B8%E5%8A%A0%20II%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：454 给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。 例如: 123456789101112A = [ 1, 2]B = [-2,-1]C = [-1, 2]D = [ 0, 2]输出:2解释:两个元组如下:1. (0, 0, 0, 1) -&gt; A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 02. (1, 1, 0, 0) -&gt; A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0 我的解答 解题思路：HashMap存前两个数组能组成的数字及其组成的次数，再遍历后两个数组，查看HashMap中是否存在两数和的相反数，如果存在，则记录出现次数，累加即为结果。 1234567891011121314151617public static int fourSumCount(int[] A, int[] B, int[] C, int[] D) &#123; int len = A.length; int count = 0; Map&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;(); for (int i=0;i&lt;len;i++)&#123; for (int j=0;j&lt;len;j++)&#123; map.put(A[i]+B[j],map.getOrDefault(A[i]+B[j],0) + 1); &#125; &#125; for (int m=0;m&lt;len;m++)&#123; for (int n=0;n&lt;len;n++)&#123; int tmp = -(C[m]+D[n]); count += map.getOrDefault(tmp,0); &#125; &#125; return count;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>hash</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Excel表列序号]]></title>
    <url>%2F2019%2F04%2F16%2FExcel%E8%A1%A8%E5%88%97%E5%BA%8F%E5%8F%B7%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：171 给定一个Excel表格中的列名称，返回其相应的列序号。例如， 12345678A -&gt; 1B -&gt; 2C -&gt; 3...Z -&gt; 26AA -&gt; 27AB -&gt; 28 ... 示例 1: 12输入: &quot;A&quot;输出: 1 示例 2: 12输入: &quot;AB&quot;输出: 28 示例 3: 12输入: &quot;ZY&quot;输出: 701 我的解答 解题思路：遍历字符串,已知字母的hash值，通过阶乘、累加得出结果 123456789public static int titleToNumber(String s) &#123; int result = 0,n = 1; for (int i = s.length() - 1;i &gt;= 0;i--)&#123; char c = s.charAt(i); result += (c - 64) * n; n *=26; &#125; return result;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>hash</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[奇偶链表]]></title>
    <url>%2F2019%2F04%2F15%2F%E5%A5%87%E5%81%B6%E9%93%BE%E8%A1%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：328 给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。 请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。 示例 1: 12输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL输出: 1-&gt;3-&gt;5-&gt;2-&gt;4-&gt;NULL 示例 2: 12输入: 2-&gt;1-&gt;3-&gt;5-&gt;6-&gt;4-&gt;7-&gt;NULL 输出: 2-&gt;3-&gt;6-&gt;7-&gt;1-&gt;5-&gt;4-&gt;NULL 说明: 应当保持奇数节点和偶数节点的相对顺序。 链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。 我的解答 解题思路：遍历链表head,分两段添加，奇数位添加到odd链表，偶数位添加到even链表,最后遍历完，把偶数链表拼接到奇数链表后面 12345678910111213141516171819202122232425262728293031public static ListNode oddEvenList(ListNode head) &#123; ListNode odd = null,even = null; ListNode oddCur = null; ListNode evenCur = null; int index = 1; while (head != null)&#123; if (index%2 == 0)&#123; if (even == null)&#123; even = new ListNode(head.val); evenCur = even; &#125;else &#123; evenCur.next = new ListNode(head.val); evenCur = evenCur.next; &#125; &#125;else &#123; if (odd == null)&#123; odd = new ListNode(head.val); oddCur = odd; &#125;else &#123; oddCur.next = new ListNode(head.val); oddCur = oddCur.next; &#125; &#125; head = head.next; index++; if (head == null)&#123; oddCur.next = even; &#125; &#125; return odd;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[相交链表]]></title>
    <url>%2F2019%2F04%2F12%2F%E7%9B%B8%E4%BA%A4%E9%93%BE%E8%A1%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：160 编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 123输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3输出：Reference of the node with value = 8输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。 示例 2： 123输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1输出：Reference of the node with value = 2输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 示例 3： 1234输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2输出：null输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。解释：这两个链表不相交，因此返回 null。 注意： 如果两个链表没有交点，返回 null. 在返回结果后，两个链表仍须保持原有的结构。 可假定整个链表结构中没有循环。 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。 我的解答 解题思路：先遍历headA和headB,得到两个链表的长度。根据长度可知两个链表的谁长谁短,然后根据两个长度的差值len，先让长的链表走len节点，最后遍历比较两个链表，知道两个链表相交 1234567891011121314151617181920212223242526272829public ListNode getIntersectionNode(ListNode headA, ListNode headB) &#123; int lenA = 0,lenB = 0; ListNode longNode = headA,shortNode = headB; while (longNode != null)&#123; lenA++; longNode = longNode.next; &#125; while (shortNode != null)&#123; lenB++; shortNode = shortNode.next; &#125; if (lenA &lt; lenB)&#123; longNode = headB; shortNode = headA; &#125;else &#123; longNode = headA; shortNode = headB; &#125; int len = Math.abs(lenA - lenB); for (int i = 0;i &lt; len;i++)&#123; longNode = longNode.next; &#125; while (longNode != shortNode)&#123; longNode = longNode.next; shortNode = shortNode.next; &#125; return longNode;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[排序链表]]></title>
    <url>%2F2019%2F04%2F11%2F%E6%8E%92%E5%BA%8F%E9%93%BE%E8%A1%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：148 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 示例 1: 12输入: 4-&gt;2-&gt;1-&gt;3输出: 1-&gt;2-&gt;3-&gt;4 示例 2: 12输入: -1-&gt;5-&gt;3-&gt;4-&gt;0输出: -1-&gt;0-&gt;3-&gt;4-&gt;5 我的解答 解法一 解题思路：通过遍历head，把值存储到List中，对List的进行排序，再对list遍历，用新的ListNode来存值 123456789101112131415161718192021222324public static ListNode sortList(ListNode head) &#123; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); while (head != null)&#123; list.add(head.val); head = head.next; &#125; Collections.sort(list, new Comparator&lt;Integer&gt;() &#123; @Override public int compare(Integer o1, Integer o2) &#123; return o1 - o2; &#125; &#125;); ListNode temp = null; for (int val:list)&#123; if (head == null)&#123; head = new ListNode(val); temp = head; &#125;else &#123; temp.next = new ListNode(val); temp = temp.next; &#125; &#125; return head;&#125; 解法二 解题思路：通过归并排序思想,用一个fast指针，一个slow指针,fast走两步,slow走一步,分层两段;再对各自两段的链表,通过递归，进行排序;最后将两段排序好，再进行合并 123456789101112131415161718192021222324252627282930313233343536373839public static ListNode sortList(ListNode head) &#123; return mergeSort(head);&#125;private static ListNode mergeSort(ListNode head)&#123; if(head == null || head.next == null) return head; ListNode fast = head; ListNode slow = head; ListNode tmp = null; while(fast != null &amp;&amp; fast.next != null)&#123; fast = fast.next.next; tmp = slow; slow = slow.next; &#125; tmp.next = null; ListNode l = mergeSort(head); ListNode r = mergeSort(slow); return merge(l,r);&#125;private static ListNode merge(ListNode l,ListNode r)&#123; ListNode head = new ListNode(0); ListNode cur = head; while(l != null &amp;&amp; r != null)&#123; if(l.val &lt; r.val)&#123; cur.next = l; cur = cur.next; l = l.next; &#125; else&#123; cur.next = r; cur = cur.next; r = r.next; &#125; &#125; if(l != null) cur.next = l; if(r != null) cur.next = r; return head.next;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[复制带随机指针的链表]]></title>
    <url>%2F2019%2F04%2F10%2F%E5%A4%8D%E5%88%B6%E5%B8%A6%E9%9A%8F%E6%9C%BA%E6%8C%87%E9%92%88%E7%9A%84%E9%93%BE%E8%A1%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：138 给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。要求返回这个链表的深拷贝。 示例： 123456输入：&#123;&quot;$id&quot;:&quot;1&quot;,&quot;next&quot;:&#123;&quot;$id&quot;:&quot;2&quot;,&quot;next&quot;:null,&quot;random&quot;:&#123;&quot;$ref&quot;:&quot;2&quot;&#125;,&quot;val&quot;:2&#125;,&quot;random&quot;:&#123;&quot;$ref&quot;:&quot;2&quot;&#125;,&quot;val&quot;:1&#125;解释：节点 1 的值是 1，它的下一个指针和随机指针都指向节点 2 。节点 2 的值是 2，它的下一个指针指向 null，随机指针指向它自己。 提示： 你必须返回给定头的拷贝作为对克隆列表的引用。 我的解答 解题思路：用HashMap来对原链表的拷贝,key是原链表，value是新链表，进行二次遍历；第一遍根据val进行赋值；第二遍为新链表添加next节点和random指针 123456789101112131415161718192021222324252627282930313233/*// Definition for a Node.class Node &#123; public int val; public Node next; public Node random; public Node() &#123;&#125; public Node(int _val,Node _next,Node _random) &#123; val = _val; next = _next; random = _random; &#125;&#125;;*/public static Node copyRandomList(Node head) &#123; Map&lt;Node,Node&gt; map = new HashMap&lt;&gt;(); Node node = head; while (node != null)&#123; Node newNode = new Node(node.val,null,null); map.put(node,newNode); node = node.next; &#125; node = head; while (node != null)&#123; map.get(node).next = map.get(node.next); map.get(node).random = map.get(node.random); node = node.next; &#125; return map.get(head);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[逆波兰表达式求值]]></title>
    <url>%2F2019%2F04%2F09%2F%E9%80%86%E6%B3%A2%E5%85%B0%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B1%82%E5%80%BC%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：150 根据逆波兰表示法，求表达式的值。有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 说明： 整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 示例 1： 123输入: [&quot;2&quot;, &quot;1&quot;, &quot;+&quot;, &quot;3&quot;, &quot;*&quot;]输出: 9解释: ((2 + 1) * 3) = 9 示例 2： 123输入: [&quot;4&quot;, &quot;13&quot;, &quot;5&quot;, &quot;/&quot;, &quot;+&quot;]输出: 6解释: (4 + (13 / 5)) = 6 示例 3： 12345678910输入: [&quot;10&quot;, &quot;6&quot;, &quot;9&quot;, &quot;3&quot;, &quot;+&quot;, &quot;-11&quot;, &quot;*&quot;, &quot;/&quot;, &quot;*&quot;, &quot;17&quot;, &quot;+&quot;, &quot;5&quot;, &quot;+&quot;]输出: 22解释: ((10 * (6 / ((9 + 3) * -11))) + 17) + 5= ((10 * (6 / (12 * -11))) + 17) + 5= ((10 * (6 / -132)) + 17) + 5= ((10 * 0) + 17) + 5= (0 + 17) + 5= 17 + 5= 22 我的解答 解法一 解题思路：用栈来存取tokens数组中的数字,根据逆波兰表达式规则,tokens数组的前两位是数字,这样用m,n来表示这两位，根据表达式规则,遇到符合就计算，将结果存入栈中，遍历完tokens，栈顶就是表达式的结果 123456789101112131415161718192021222324252627282930313233public static int evalRPN(String[] tokens) &#123; Stack&lt;Integer&gt; stack = new Stack&lt;&gt;(); int n=0,m=0; for (int i=0;i&lt;tokens.length;i++)&#123; String token = tokens[i]; switch (token)&#123; case &quot;+&quot;: n=stack.pop(); m=stack.pop(); stack.push(m+n); break; case &quot;-&quot;: n=stack.pop(); m=stack.pop(); stack.push(m-n); break; case &quot;*&quot;: n=stack.pop(); m=stack.pop(); stack.push(m*n); break; case &quot;/&quot;: n=stack.pop(); m=stack.pop(); stack.push(m/n); break; default: stack.push(Integer.parseInt(token)); break; &#125; &#125; return stack.pop();&#125; 解法二 解题思路：跟解法一思路差不多,从数组尾部开始递归,直到遇到tokens的第一个符号，开始计算，直到递归完成，返回最终结果 12345678910111213141516171819private static int N =-1;public static int evalRPN(String[] tokens) &#123; if(N==-1) N=tokens.length-1; String s = tokens[N--]; char c = s.charAt(0); if(s.length()==1&amp;&amp;&quot;+-*/&quot;.indexOf(c)!=-1)&#123; int a = evalRPN(tokens); int b = evalRPN(tokens); switch(c)&#123; case &apos;+&apos;:return a+b; case &apos;-&apos;:return b-a; case &apos;*&apos;:return a*b; case &apos;/&apos;:return b/a; default:break; &#125; &#125; return Integer.parseInt(s);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>堆栈</tag>
        <tag>队列</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Java多线程]]></title>
    <url>%2F2019%2F04%2F08%2FJava%E5%A4%9A%E7%BA%BF%E7%A8%8B%2F</url>
    <content type="text"><![CDATA[线程的生命周期 新建(New)：新创建了一个线程对象。 可运行(Runnable)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。 运行(Running)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。 阻塞(Blocked)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种： (一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。 (二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。 (三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。 终止(Terminated)：线程run()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。 下图是线程的状态图 并发编程Java内存模式（JMM）： Java所有变量都存储在主内存中 每个线程都有自己独立的工作内存，里面保存该线程的使用到的变量副本（该副本就是主内存中该变量的一份拷贝） 线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接在主内存中读写 不同线程之间无法直接访问其他线程工作内存中的变量，线程间变量值的传递需要通过主内存来完成。 线程A对共享变量的修改，要想被线程B及时看到，必须经过如下2个过程： 把工作内存A中更新过的共享变量刷新到主内存中 将主内存中最新的共享变量的值更新到工作内存B中 详细的内存模型介绍：请参考这篇文章java内存模型以及happens-before规则 线程安全的三个特性：原子性、有序性和可见性 可见性：一个线程对共享变量的修改，更够及时的被其他线程看到有序性：如果在本线程内观察，所有的操作都是有序的；如果在一个线程观察另一个线程，所有的操作都 是无序的原子性：即不可再分了，不能分为多步操作。比如赋值或者return。比如”a = 1;”和 “return a;”这样的操作 都具有原子性。类似”a += b”这样的操作不具有原子性，在某些JVM中”a += b”可能要经过这样三个步骤：① 取出a和b② 计算a+b③ 将计算结果写入内存 Synchronized：保证可见性和原子性 Synchronized能够实现原子性和可见性；在Java内存模型中，synchronized规定，线程在加锁时，先清空工作内存→在主内存中拷贝最新变量的副本到工作内存→执行完代码→将更改后的共享变量的值刷新到主内存中→释放互斥锁。 Volatile：保证可见性，但不保证操作的原子性 Volatile实现内存可见性是通过store和load指令完成的；也就是对volatile变量执行写操作时，会在写操作后加入一条store指令，即强迫线程将最新的值刷新到主内存中；而在读操作时，会加入一条load指令，即强迫从主内存中读入变量的值。但volatile不保证volatile变量的原子性 Synchronized和Volatile的比较 Synchronized保证内存可见性和操作的原子性 Volatile只能保证内存可见性 Volatile不需要加锁，比Synchronized更轻量级，并不会阻塞线程（volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。）volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化（如编译器重排序的优化）. volatile是变量修饰符，仅能用于变量，而synchronized是一个方法或块的修饰符。 volatile本质是在告诉JVM当前变量在寄存器中的值是不确定的，使用前，需要先从主存中读取，因此可以实现可见性。而对n=n+1,n++等操作时，volatile关键字将失效，不能起到像synchronized一样的线程同步（原子性）的效果 详细的线程相关知识介绍：这篇文章相关面试题：这篇文章]]></content>
      <categories>
        <category>Java</category>
      </categories>
      <tags>
        <tag>多线程</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[扁平化嵌套列表迭代器]]></title>
    <url>%2F2019%2F04%2F08%2F%E6%89%81%E5%B9%B3%E5%8C%96%E5%B5%8C%E5%A5%97%E5%88%97%E8%A1%A8%E8%BF%AD%E4%BB%A3%E5%99%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：341 给定一个嵌套的整型列表。设计一个迭代器，使其能够遍历这个整型列表中的所有整数。列表中的项或者为一个整数，或者是另一个列表。 示例 1: 123输入: [[1,1],2,[1,1]]输出: [1,1,2,1,1]解释: 通过重复调用 next 直到 hasNext 返回false，next 返回的元素的顺序应该是: [1,1,2,1,1]。 示例 2: 123输入: [1,[4,[6]]]输出: [1,4,6]解释: 通过重复调用 next 直到 hasNext 返回false，next 返回的元素的顺序应该是: [1,4,6]。 我的解答 解题思路：用堆来遍历存储，遵循先进先出的原则，每次调用next(),调用poll()移除头部，知道hasNext()判断没有数据 12345678910111213141516171819202122232425262728293031323334353637public class NestedIterator implements Iterator&lt;Integer&gt; &#123; private Queue&lt;Integer&gt; queue = new ArrayDeque&lt;&gt;(); public NestedIterator(List&lt;NestedInteger&gt; nestedList) &#123; add(nestedList); &#125; private void add(List&lt;NestedInteger&gt; nestedList)&#123; for (NestedInteger nestedInteger:nestedList)&#123; if (nestedInteger.isInteger())&#123; queue.offer(nestedInteger.getInteger()); &#125;else &#123; add(nestedInteger.getList()); &#125; &#125; &#125; @Override public Integer next() &#123; return queue.poll(); &#125; @Override public boolean hasNext() &#123; return !queue.isEmpty(); &#125; public interface NestedInteger &#123; public boolean isInteger(); public Integer getInteger(); public List&lt;NestedInteger&gt; getList(); &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>堆栈</tag>
        <tag>队列</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[基本计算器 II]]></title>
    <url>%2F2019%2F04%2F04%2F%E5%9F%BA%E6%9C%AC%E8%AE%A1%E7%AE%97%E5%99%A8%20II%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：227 实现一个基本的计算器来计算一个简单的字符串表达式的值。字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。 示例 1: 12输入: &quot;3+2*2&quot;输出: 7 示例 2: 12输入: &quot; 3/2 &quot;输出: 1 示例 3: 12输入: &quot; 3+5 / 2 &quot;输出: 5 说明： 你可以假设所给定的表达式都是有效的。 请不要使用内置的库函数 eval。 我的解答: 解题思路：利用栈的方式解决运算优先级的问题 当为加减时放入栈中 当为乘除时讲栈顶元素与最近获得一个数进行运算 12345678910111213141516171819202122232425262728293031323334public static int calculate(String s) &#123; Stack&lt;Integer&gt; stack = new Stack&lt;&gt;(); int num = 0; char op = &apos;+&apos;; for (int i=0;i&lt;s.length();i++) &#123; char c = s.charAt(i); if (c &gt;= &apos;0&apos;) &#123; num = num*10+c-&apos;0&apos;; &#125; if (c != &apos; &apos; &amp;&amp; c &lt; &apos;0&apos; || i == s.length()-1) &#123; switch (op)&#123; case &apos;+&apos;: stack.push(num); break; case &apos;-&apos;: stack.push(-num); break; case &apos;*&apos;: stack.push(stack.pop() * num); break; case &apos;/&apos;: stack.push(stack.pop() / num); break; &#125; num = 0; op = c; &#125; &#125; int result = 0; while (!stack.empty())&#123; result += stack.pop(); &#125; return result;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>堆栈</tag>
        <tag>队列</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[滑动窗口最大值]]></title>
    <url>%2F2019%2F04%2F03%2F%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：239 给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口 k 内的数字。滑动窗口每次只向右移动一位。返回滑动窗口最大值。 示例: 123456789101112输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3输出: [3,3,5,5,6,7] 解释: 滑动窗口的位置 最大值--------------- -----[1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7 3 1 3 [-1 -3 5] 3 6 7 5 1 3 -1 [-3 5 3] 6 7 5 1 3 -1 -3 [5 3 6] 7 6 1 3 -1 -3 5 [3 6 7] 7 注意： 你可以假设 k 总是有效的，1 ≤ k ≤ 输入数组的大小，且输入数组不为空。 进阶： 你能在线性时间复杂度内解决此题吗？ 我的解答 解法一 解题思路：新建result的数组，可以得知数组长度为num.length-k+1;遍历数组nums,维护一个大小为k的队列，每次读取一个新值时，把最左边的数移除，新值加入队列，这样栈顶的数都是最大值 1234567891011121314151617181920212223public static int[] maxSlidingWindow(int[] nums, int k) &#123; int n = nums.length; if (n==0 || k==0) return new int[]&#123;&#125;; int[] result = new int[n-k+1]; PriorityQueue&lt;Integer&gt; queue = new PriorityQueue&lt;&gt;(new Comparator&lt;Integer&gt;() &#123; @Override public int compare(Integer o1, Integer o2) &#123; return o2 - o1; &#125; &#125;); int index = 0; for(int i=0;i&lt;n;i++)&#123; queue.offer(nums[i]); if (queue.size() == k)&#123; result[index] = queue.peek(); queue.remove(nums[index]); if (index == n - k) break; index++; &#125; &#125; return result;&#125; 解法二 解题思路：使用双向队列，当遇到新值时，将新值和双向队列的末尾比较，如果末尾比新值小，则把末尾扔掉，直到该队列的末尾比新值大或者队列为空。这样，可以保证队列里的元素是从头到尾降序的，由于队列里只有窗口内的数，所以其实就是窗口内第一大，第二大，第三大…的数。保持队列内只有窗口的数，就是与解法一相同，来新值时，把最左边的数的下标移除，然后加入新值下标。然而由于在加新值的时候，已经把很多没用的数给扔了，这样队列头部的数并不一定是窗口最左边的数。这里的技巧是，队列中存的是那个数在原数组中的下标，这样我们既可以知道这个数的值，也可以知道该数是不是窗口最左边的数。 12345678910111213141516171819public static int[] maxSlidingWindow(int[] nums, int k) &#123; int n = nums.length; if (n==0 || k==0) return new int[]&#123;&#125;; ArrayDeque&lt;Integer&gt; deque = new ArrayDeque&lt;&gt;(); int[] result = new int[n-k+1]; for(int i=0;i&lt;n;i++)&#123; if (!deque.isEmpty() &amp;&amp; deque.peekFirst() == i - k)&#123; deque.poll(); &#125; while (!deque.isEmpty() &amp;&amp; nums[deque.peekLast()] &lt; nums[i])&#123; deque.removeLast(); &#125; deque.offerLast(i); if (i+1 &gt;= k)&#123; result[i+1 - k] = nums[deque.peek()]; &#125; &#125; return result;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>困难</tag>
        <tag>堆栈</tag>
        <tag>队列</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[数据流的中位数]]></title>
    <url>%2F2019%2F04%2F02%2F%E6%95%B0%E6%8D%AE%E6%B5%81%E7%9A%84%E4%B8%AD%E4%BD%8D%E6%95%B0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：295 中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。例如，[2,3,4] 的中位数是 3[2,3] 的中位数是 (2 + 3) / 2 = 2.5设计一个支持以下两种操作的数据结构： void addNum(int num) - 从数据流中添加一个整数到数据结构中。 double findMedian() - 返回目前所有元素的中位数。 示例： 12345addNum(1)addNum(2)findMedian() -&gt; 1.5addNum(3) findMedian() -&gt; 2 进阶: 如果数据流中所有整数都在 0 到 100 范围内，你将如何优化你的算法？ 如果数据流中 99% 的整数都在 0 到 100 范围内，你将如何优化你的算法？ 我的解答 解法一 解题思路：将int用List存储，然后转换新数组，按从小到大排序，根据List的大小是否为奇偶数来取中位数 123456789101112131415161718192021222324252627282930public class MedianFinder &#123; private List&lt;Integer&gt; list; /** initialize your data structure here. */ public MedianFinder() &#123; list = new ArrayList&lt;&gt;(); &#125; public void addNum(int num) &#123; list.add(num); &#125; public double findMedian() &#123; double median = 0; int index = 0; int n = list.size(); Integer[] arr = new Integer[n]; arr = list.toArray(arr); Arrays.sort(arr); if (n%2 == 0)&#123; index = (n / 2) - 1; median = (arr[index] + arr[index+1])/2.0; &#125;else &#123; index = n / 2; median = arr[index]; &#125; return median; &#125;&#125; 解法二 解题思路：用大小堆来存数据，小堆来存后半段大的数据(从小到大),大堆来前半段数据（从大到小,如果总数是奇数，取小堆栈顶的值为中位数；如果是偶数，取大小堆栈顶数据的平均值为中位数 123456789101112131415161718192021222324252627282930313233343536373839404142public class MedianFinder &#123; private int count = 0; private PriorityQueue&lt;Integer&gt; min; private PriorityQueue&lt;Integer&gt; max; /** * initialize your data structure here. */ @RequiresApi(api = Build.VERSION_CODES.N) public MedianFinder() &#123; min = new PriorityQueue&lt;&gt;(); max = new PriorityQueue&lt;&gt;(new Comparator&lt;Integer&gt;() &#123; @Override public int compare(Integer o1, Integer o2) &#123; return o2 - o1; &#125; &#125;); &#125; public void addNum(int num) &#123; if (count % 2 == 0) &#123; max.offer(num); int temp = max.poll(); min.offer(temp); &#125; else &#123; min.offer(num); int temp = min.poll(); max.offer(temp); &#125; count++; &#125; public double findMedian() &#123; if (count % 2 == 0) &#123; return (max.peek() + min.peek()) / 2.0; &#125; else &#123; return min.peek(); &#125; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>困难</tag>
        <tag>堆栈</tag>
        <tag>队列</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[有序矩阵中第K小的元素]]></title>
    <url>%2F2019%2F04%2F01%2F%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：347 给定一个非空的整数数组，返回其中出现频率前 k 高的元素。 示例 1: 12输入: nums = [1,1,1,2,2,3], k = 2输出: [1,2] 示例 2: 12输入: nums = [1], k = 1输出: [1] 说明： 你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。 你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。 我的解答 解题思路：把数组的数据放大Map存起来，key是具体数字，value是在数组出现的次数，然后按从大到小排列，最后取前k个数字 12345678910111213141516171819202122232425262728293031323334public static List&lt;Integer&gt; topKFrequent(int[] nums, int k) &#123; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); PriorityQueue&lt;Map.Entry&lt;Integer,Integer&gt;&gt; pq = new PriorityQueue&lt;&gt; (new Comparator&lt;Map.Entry&lt;Integer, Integer&gt;&gt;() &#123; @Override public int compare(Map.Entry&lt;Integer, Integer&gt; o1, Map.Entry&lt;Integer, Integer&gt; o2) &#123; return o2.getValue()-o1.getValue(); &#125; &#125;); Map&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;(); for (int i = 0; i &lt; nums.length; i++) &#123; if (map.containsKey(nums[i])) map.put(nums[i], map.get(nums[i]) + 1); else map.put(nums[i], 1); &#125; Set&lt;Map.Entry&lt;Integer,Integer&gt;&gt; set = map.entrySet(); for (Map.Entry&lt;Integer,Integer&gt; entry : set) &#123; pq.add(entry); &#125; for (int i = 0; i &lt; k; i++) &#123; list.add(pq.poll().getKey()); &#125; return list;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>堆栈</tag>
        <tag>队列</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[有序矩阵中第K小的元素]]></title>
    <url>%2F2019%2F03%2F30%2F%E6%9C%89%E5%BA%8F%E7%9F%A9%E9%98%B5%E4%B8%AD%E7%AC%ACK%E5%B0%8F%E7%9A%84%E5%85%83%E7%B4%A0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：378 给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。请注意，它是排序后的第k小元素，而不是第k个元素。 示例: 12345678matrix = [ [ 1, 5, 9], [10, 11, 13], [12, 13, 15]],k = 8,返回 13。 说明: 你可以假设 k 的值永远是有效的, 1 ≤ k ≤ n2 。 我的解答 解法一(遍历) 解题思路：用新数组存储矩阵所有元素，最后排序，取出k-1个元素就是想要的结果 123456789101112131415public static int kthSmallest(int[][] matrix, int k) &#123; int row = matrix.length; int col = matrix[0].length; int n = row * col; int[] arr = new int[n]; int index = 0; for (int i=0;i&lt;matrix.length;i++)&#123; for (int j=0;j&lt;matrix[i].length;j++)&#123; arr[index] = matrix[i][j]; index++; &#125; &#125; Arrays.sort(arr); return arr[k];&#125; 解法二(二分查找) 解题思路：由于是有序矩阵，那么左上角的数字一定是最小的，而右下角的数字一定是最大的，所以这个是搜索的范围，然后算出中间数字mid，由于矩阵中不同行之间的元素并不是严格有序的，所以要在每一行都查找一下mid，遍历查找第一个大于目标数的元素，如果目标数在比该行的尾元素大，则count返回该行元素的个数，如果目标数比该行首元素小，则换下一行, 遍历完所有的行可以找出中间数是第几小的数，然后与k比较，进行二分查找，left和right最终会相等，并且会变成数组中第k小的数字。 1234567891011121314151617181920212223public static int kthSmallest(int[][] matrix, int k) &#123; int n = matrix.length; int left = matrix[0][0]; int right = matrix[n-1][n-1]; while (left &lt; right)&#123; int mid = left + (right-left)/2; int count = 0; for (int i=n-1,j=0;i&gt;=0 &amp;&amp; j&lt;n;)&#123; if (matrix[i][j] &gt; mid)&#123; i--; &#125;else &#123; j++; count += i+1; &#125; &#125; if (count &lt; k)&#123; left = mid + 1; &#125;else &#123; right = mid; &#125; &#125; return left;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数组</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[数组中的第K个最大元素]]></title>
    <url>%2F2019%2F03%2F28%2F%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E7%AC%ACK%E4%B8%AA%E6%9C%80%E5%A4%A7%E5%85%83%E7%B4%A0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：215 在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。 示例 1: 12输入: [3,2,1,5,6,4] 和 k = 2输出: 5 示例 2: 12输入: [3,2,3,1,2,4,5,5,6] 和 k = 4输出: 4 说明: 你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。 我的解答： 解法一 解题思路：用PriorityQueue(添加数据，会进行从小大排序)来存储数组数据，超过k的大小，就移除；遍历完nums，取出的第一个数就对应的最大元素 12345678910public static int findKthLargest(int[] nums, int k) &#123; PriorityQueue&lt;Integer&gt; queue = new PriorityQueue&lt;&gt;(); for (int num:nums)&#123; queue.add(num); if (queue.size() &gt; k)&#123; queue.poll(); &#125; &#125; return queue.peek();&#125; 解法二 解题思路：先对数组nums进行从小大排序，取出数组倒数第k个下标的数就是对应的最大元素 1234public static int findKthLargest(int[] nums, int k) &#123; Arrays.sort(nums); return nums[nums.length - k];&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>堆栈</tag>
        <tag>队列</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[View、WindowsheViewRootImpl的关系]]></title>
    <url>%2F2019%2F03%2F27%2FView%E3%80%81Windows%E5%92%8CViewRootImpl%E7%9A%84%E5%85%B3%E7%B3%BB%2F</url>
    <content type="text"><![CDATA[梳理在Activity的启动过程中，View、Windows和ViewRootImpl的关系。 下图是View、WindowsheViewRootImpl的关系流程图： 在Activity的启动过程中，在ActivityThread中调用performLaunchActivity方法会调用Activity的attach()方法，这时会创建PhoneWindow； Window创建后，会调用setWindowManager方法，让Window与WIndowManager进行绑定； 之后在handleResumeActivity方法中DecorView与WindowManager进行了绑定，即WM调用了addView方法。addView的最终执行是由WindowManagerGlobal来执行。 在执行addView时，创建了ViewRootImpl（其实对View的最终操作，如添加，删除等都是它来完成的），之后调用setView方法 接下来就是对View的绘制过程，然后ViewRootImpl会通过WindowSession跟WMS（WindowManagerService）进行通信，完成对Window的添加 完成Window的添加后，最后让DecorView显示出来。]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>View</tag>
        <tag>Window</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[除自身以外数组的乘积]]></title>
    <url>%2F2019%2F03%2F27%2F%E9%99%A4%E8%87%AA%E8%BA%AB%E4%BB%A5%E5%A4%96%E6%95%B0%E7%BB%84%E7%9A%84%E4%B9%98%E7%A7%AF%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：238 给定长度为 n 的整数数组 nums，其中 n &gt; 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。 示例: 12输入: [1,2,3,4]输出: [24,12,8,6] 说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。 进阶： 你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。） 我的解答 解法一 解题思路：每一个数都是除了自身之外，左边数的乘积 乘以 右边数的乘积 12345678910111213141516public static int[] productExceptSelf(int[] nums) &#123; int n = nums.length; int[] newNums = new int[n]; int[] left = new int[n]; int[] right = new int[n]; left[0] = 1; right[n-1] = 1; for (int i=1;i&lt;n;i++)&#123; left[i] = nums[i-1] * left[i-1]; right[n-1-i] =nums[n-i] * right[n-i]; &#125; for (int i=0;i&lt;nums.length;i++)&#123; newNums[i] = left[i] * right[i]; &#125; return newNums;&#125; 解法二 解题思路：对解法一的优化版本 123456789101112131415public static int[] productExceptSelf(int[] nums) &#123; int n = nums.length; int[] newNums = new int[n]; int left = 1; int right = 1; for (int i=0;i&lt;n;i++)&#123; newNums[i] = left; left *= nums[i]; &#125; for (int i=n-1;i&gt;=0;i--)&#123; newNums[i] *= right; right *= nums[i]; &#125; return newNums;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数组</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[递增的三元子序列]]></title>
    <url>%2F2019%2F03%2F26%2F%E9%80%92%E5%A2%9E%E7%9A%84%E4%B8%89%E5%85%83%E5%AD%90%E5%BA%8F%E5%88%97%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：334 给定一个未排序的数组，判断这个数组中是否存在长度为 3 的递增子序列。 数学表达式如下: 如果存在这样的 i, j, k, 且满足 0 ≤ i &lt; j &lt; k ≤ n-1，使得 arr[i] &lt; arr[j] &lt; arr[k] ，返回 true ; 否则返回 false 。 说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1) 。 示例 1: 12输入: [1,2,3,4,5]输出: true 示例 2: 12输入: [5,4,3,2,1]输出: false 我的解答 解题思路：确定数组中是否存在三个递增的数，可以先后确定第一个，第二个，是否存在第三个，如果存在，证明是符合需求，反之亦然 12345678910111213141516171819public static boolean increasingTriplet(int[] nums) &#123; if (nums.length &lt; 3) return false; int first = Integer.MAX_VALUE,second = Integer.MAX_VALUE; for (int num:nums)&#123; if (first &gt; num)&#123; first = num; continue; &#125; if (first &lt; num &amp;&amp; num &lt; second)&#123; second = num; continue; &#125; if (num &gt; second)&#123; return true; &#125; &#125; return false;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数组</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[乘积最大子序列]]></title>
    <url>%2F2019%2F03%2F25%2F%E4%B9%98%E7%A7%AF%E6%9C%80%E5%A4%A7%E5%AD%90%E5%BA%8F%E5%88%97%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：152 给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。 示例 1: 123输入: [2,3,-2,4]输出: 6解释: 子数组 [2,3] 有最大乘积 6。 示例 2: 123输入: [-2,0,-1]输出: 0解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。 我的解答： 解答一（暴力法） 12345678910111213public int maxProduct(int[] nums) &#123; int result = nums[0]; for (int i=0;i&lt;nums.length;i++)&#123; int product = 1; for (int j=i;i&lt;nums.length;j++)&#123; product *= nums[i]; if (product &gt; result)&#123; result = product; &#125; &#125; &#125; return result;&#125; 解答二（动态规划） 解题思路：考虑到乘积子序列中有正也有负或者0，虽然只要求一个最大积，但由于负数的存在，不但纪录最大乘积，也要记录最小乘积。利用动态规划来求解，用max[i]来表示以nums[i]结尾的最大连续子串的乘积，用min[i]表示以nums[i]结尾的最小连续子串的乘积 123456789101112public int maxProduct(int[] nums) &#123; int max = nums[0]; int min = nums[0]; int result = nums[0]; for (int i=1;i&lt;nums.length;i++)&#123; int tem = max; max = Math.max(Math.max(max*nums[i],min*nums[i]),nums[i]); min = Math.min(Math.min(tem*nums[i],min*nums[i]),nums[i]); result = Math.max(max,result); &#125; return result;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数组</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[单词搜索 II]]></title>
    <url>%2F2019%2F03%2F24%2F%E5%8D%95%E8%AF%8D%E6%90%9C%E7%B4%A2%20II%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：212 给定一个二维网格 board 和一个字典中的单词列表 words，找出所有同时在二维网格和字典中出现的单词。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。 示例: 12345678910输入: words = [&quot;oath&quot;,&quot;pea&quot;,&quot;eat&quot;,&quot;rain&quot;] and board =[ [&apos;o&apos;,&apos;a&apos;,&apos;a&apos;,&apos;n&apos;], [&apos;e&apos;,&apos;t&apos;,&apos;a&apos;,&apos;e&apos;], [&apos;i&apos;,&apos;h&apos;,&apos;k&apos;,&apos;r&apos;], [&apos;i&apos;,&apos;f&apos;,&apos;l&apos;,&apos;v&apos;]]输出: [&quot;eat&quot;,&quot;oath&quot;] 说明: 你可以假设所有输入都由小写字母 a-z 组成。 提示: 你需要优化回溯算法以通过更大数据量的测试。你能否早点停止回溯？ 如果当前单词不存在于所有单词的前缀中，则可以立即停止回溯。什么样的数据结构可以有效地执行这样的操作？散列表是否可行？为什么？ 前缀树如何？如果你想学习如何实现一个基本的前缀树，请先查看： 实现Trie（前缀树）/)。 我的解答 解法一 解题思路：承接 ‘单词搜索’ 的基础上，遍历单词数组 12345678910111213141516171819202122232425262728293031323334353637383940414243public List&lt;String&gt; findWords(char[][] board, String[] words) &#123; List&lt;String&gt; list = new ArrayList&lt;&gt;(); for (String word:words)&#123; if (exist(board,word) &amp;&amp; !list.contains(word))&#123; list.add(word); &#125; &#125; return list;&#125;private boolean exist(char[][] board, String word) &#123; if (word.length() == 0 || board.length == 0)&#123; return false; &#125; boolean[][] flag = new boolean[board.length][board[0].length]; for (int i=0;i&lt;board.length;i++)&#123; for (int j=0;j&lt;board[i].length;j++)&#123; if (board[i][j] == word.charAt(0))&#123; if (find(board,word,0,i,j,flag))&#123; return true; &#125; &#125; &#125; &#125; return false;&#125;private boolean find(char[][] board, String word,int index,int i,int j,boolean[][] flag)&#123; if (index == word.length())&#123; return true; &#125; boolean result = false; if (i&gt;=0 &amp;&amp; i&lt;board.length &amp;&amp; j&gt;=0 &amp;&amp; j&lt;board[i].length &amp;&amp; !flag[i][j] &amp;&amp; word.charAt(index) == board[i][j])&#123; flag[i][j] = true; index += 1; result = find(board,word,index,i+1,j,flag) || find(board,word,index,i-1,j,flag) || find(board,word,index,i,j+1,flag) || find(board,word,index,i,j-1,flag); if (result == false)&#123; index -= 1; flag[i][j] = false; &#125; &#125; return result;&#125; 解法二(LeetCode最优解) 解题思路：单词列表利用前缀树来存储，然后深度遍历 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293class Solution &#123; public class Node &#123; Node[] children = new Node[26]; char c; String result; public Node(char c) &#123; this.c = c; &#125; public void insert(String word, int start) &#123; if (start &gt;= word.length()) return; char v = word.charAt(start); if (start == word.length() - 1) &#123; //last one Node child = children[v - 97]; if (child == null) &#123; children[v - 97] = child = new Node(v); &#125; child.result = word; &#125; else &#123; Node child = children[v - 97]; if (child == null) &#123; children[v - 97] = child = new Node(v); &#125; child.insert(word, start + 1); &#125; &#125; public Node next(char c) &#123; if (97 &lt;= c &amp;&amp; c &lt; 97 + 26) &#123; return children[c - 97]; &#125; else &#123; return null; &#125; &#125; &#125; char[][] board; int h = 0; int w = 0; boolean[][] used; Set&lt;String&gt; r; public List&lt;String&gt; findWords(char[][] board, String[] words) &#123; if (board.length == 0 || board[0].length == 0) &#123; return new ArrayList&lt;&gt;(); &#125; this.board = board; h = board.length; w = board[0].length; used = new boolean[h][w]; r = new HashSet&lt;&gt;(); Node root = new Node(&apos; &apos;); for (String word : words) &#123; root.insert(word, 0); &#125; for (int y = 0; y &lt; h; y++) &#123; for (int x = 0; x &lt; w; x++) &#123; used[y][x] = true; Node next = root.next(board[y][x]); if (next != null) &#123; find(x, y, next); &#125; used[y][x] = false; &#125; &#125; List&lt;String&gt; list = new ArrayList&lt;&gt;(r); return list; &#125; private void find(int x, int y, Node curr) &#123; if (curr == null) return; if (curr.result != null) &#123; r.add(curr.result); &#125; if (x &gt; 0) go(x - 1, y, curr); if (x &lt; w - 1) go(x + 1, y, curr); if (y &gt; 0) go(x, y - 1, curr); if (y &lt; h - 1) go(x, y + 1, curr); &#125; private void go(int x, int y, Node curr) &#123; if (used[y][x]) return; Node next = curr.next(board[y][x]); if (next != null) &#123; used[y][x] = true; find(x, y, next); used[y][x] = false; &#125; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>困难</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[单词搜索]]></title>
    <url>%2F2019%2F03%2F22%2F%E5%8D%95%E8%AF%8D%E6%90%9C%E7%B4%A2%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：79 给定一个二维网格和一个单词，找出该单词是否存在于网格中。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 示例: 12345678910board =[ [&apos;A&apos;,&apos;B&apos;,&apos;C&apos;,&apos;E&apos;], [&apos;S&apos;,&apos;F&apos;,&apos;C&apos;,&apos;S&apos;], [&apos;A&apos;,&apos;D&apos;,&apos;E&apos;,&apos;E&apos;]]给定 word = &quot;ABCCED&quot;, 返回 true.给定 word = &quot;SEE&quot;, 返回 true.给定 word = &quot;ABCB&quot;, 返回 false. 我的解答 解题思路：首页找到二维数组与单词第一个字母匹配的下标，找到之后，通过回溯算法，记录上下左右位置的字符是否匹配，层层递进，知道全部匹配单词 12345678910111213141516171819202122232425262728293031323334353637383940public boolean exist(char[][] board, String word) &#123; if (word.length() == 0 || board.length == 0)&#123; return false; &#125; boolean[][] flag = new boolean[board.length][board[0].length]; for (int i=0;i&lt;board.length;i++)&#123; for (int j=0;j&lt;board[i].length;j++)&#123; if (board[i][j] == word.charAt(0))&#123; if (find(board,word,0,i,j,flag))&#123; return true; &#125; &#125; &#125; &#125; return false;&#125;private boolean find(char[][] board, String word,int index,int i,int j,boolean[][] flag)&#123; if (index == word.length())&#123; return true; &#125; boolean result = false; if (i&gt;=0 &amp;&amp; i&lt;board.length &amp;&amp; j&gt;=0 &amp;&amp; j&lt;board[i].length &amp;&amp; !flag[i][j] &amp;&amp; word.charAt(index) == board[i][j])&#123; flag[i][j] = true; index += 1; result = find(board,word,index,i+1,j,flag) || find(board,word,index,i-1,j,flag) || find(board,word,index,i,j+1,flag) || find(board,word,index,i,j-1,flag); if (result == false)&#123; index -= 1; flag[i][j] = false; &#125; &#125; return result;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[实现 Trie (前缀树)]]></title>
    <url>%2F2019%2F03%2F21%2F%E5%AE%9E%E7%8E%B0%20Trie%20(%E5%89%8D%E7%BC%80%E6%A0%91)%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：208 实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。 示例: 12345678Trie trie = new Trie();trie.insert(&quot;apple&quot;);trie.search(&quot;apple&quot;); // 返回 truetrie.search(&quot;app&quot;); // 返回 falsetrie.startsWith(&quot;app&quot;); // 返回 truetrie.insert(&quot;app&quot;); trie.search(&quot;app&quot;); // 返回 true 说明: 你可以假设所有的输入都是由小写字母 a-z 构成的。 保证所有输入均为非空字符串。 我的解答 解题思路：通过不断的插入新的字符串来丰富26叉数（依据6个英文字母） 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556public class Trie &#123; private TreeNode node; /** Initialize your data structure here. */ public Trie() &#123; node = new TreeNode(); &#125; /** Inserts a word into the trie. */ public void insert(String word) &#123; TreeNode node = this.node; for (char c:word.toCharArray())&#123; if (node.child[c - &apos;a&apos;] == null)&#123; node.child[c - &apos;a&apos;] = new TreeNode(); &#125; node = node.child[c - &apos;a&apos;]; &#125; node.value = word; &#125; /** Returns if the word is in the trie. */ public boolean search(String word) &#123; TreeNode node = this.node; for (char c:word.toCharArray())&#123; if (node.child[c - &apos;a&apos;] == null)&#123; return false; &#125; node = node.child[c - &apos;a&apos;]; &#125; return node.value.equals(word); &#125; /** Returns if there is any word in the trie that starts with the given prefix. */ public boolean startsWith(String prefix) &#123; TreeNode node = this.node; for (char c:prefix.toCharArray())&#123; if (node.child[c - &apos;a&apos;] == null)&#123; return false; &#125; node = node.child[c - &apos;a&apos;]; &#125; return true; &#125; class TreeNode&#123; String value; TreeNode[] child; public TreeNode()&#123; value = &quot;&quot;; child = new TreeNode[26]; &#125; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Binder机制]]></title>
    <url>%2F2019%2F03%2F20%2FBinder%E6%9C%BA%E5%88%B6%2F</url>
    <content type="text"><![CDATA[Binder是Android系统进程间通信（IPC）方式之一。传统的IPC如管道、Scoket等，都是属于内核一部分，通过内核来进行跨进程通信。而Binder不属于内核，Android利用Linux的动态内核加载技术，将Binder驱动挂载为动态内核，然后通过Binder驱动以mmap的方式将内核空间与接收方的用户空间进行内存映射。 内存映射(mmap)：将用户空间的一块内存区域映射到内核空间。映射关系建立后，用户对这块内存区域的修改可以直接反应到内核空间；反之内核空间对这段区域的修改也能直接反应到用户空间。 Binder通信原理 首先 Binder 驱动在内核空间创建一个数据接收缓存区； 接着在内核空间开辟一块内核缓存区，建立内核缓存区和内核中数据接收缓存区之间的映射关系，以及内核中数据接收缓存区和接收进程用户空间地址的映射关系； 数据发送进程调用系统copy_from_user()方法，将数据copy到内核缓存区，由于内核缓存区和数据接收进程的用户空间存在内存映射，相当于将数据发送到接收进程的用户空间 下图是Binder通信原理： Binder通信模型Binder框架定义了四个角色：Server，Client，ServiceManager以及Binder驱动。其中Server，Client，ServiceManager运行于用户空间，驱动运行于内核空间。这四个角色的关系和互联网类似：Server是服务器，Client是客户终端，ServiceManager是域名服务器（DNS），驱动是路由器。 关于通信模型的详细介绍可以参考这篇文章 Binder通信过程 Android在启动时，SystemServer通过Binder驱动将自己注册为ServiceManager； Server通过Binder驱动向ServiceManager注册Binder(Server中的Binder实体)，表明可以对外可以提供服务； Client通过Binder驱动查询，可以获得这个Binder实体的引用； Client获得Server的引用后，就可以Binder驱动发送数据和获取数据 下图是Binder的通信过程：]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>Binder</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[单词拆分 II]]></title>
    <url>%2F2019%2F03%2F20%2F%E5%8D%95%E8%AF%8D%E6%8B%86%E5%88%86%20II%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：140 给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。 说明： 分隔时可以重复使用字典中的单词。 你可以假设字典中没有重复的单词。 示例 1： 12345678输入:s = &quot;catsanddog&quot;wordDict = [&quot;cat&quot;, &quot;cats&quot;, &quot;and&quot;, &quot;sand&quot;, &quot;dog&quot;]输出:[ &quot;cats and dog&quot;, &quot;cat sand dog&quot;] 示例 2： 12345678910输入:s = &quot;pineapplepenapple&quot;wordDict = [&quot;apple&quot;, &quot;pen&quot;, &quot;applepen&quot;, &quot;pine&quot;, &quot;pineapple&quot;]输出:[ &quot;pine apple pen apple&quot;, &quot;pineapple pen apple&quot;, &quot;pine applepen apple&quot;]解释: 注意你可以重复使用字典中的单词。 示例 3： 12345输入:s = &quot;catsandog&quot;wordDict = [&quot;cats&quot;, &quot;dog&quot;, &quot;sand&quot;, &quot;and&quot;, &quot;cat&quot;]输出:[] 我的解答 解题思路：动态规划先判断字符串s是否符合单词拆分，然后在通过深度遍历加回溯组合字符串 12345678910111213141516171819202122232425262728293031323334353637383940414243444546public static List&lt;String&gt; wordBreak(String s, List&lt;String&gt; wordDict) &#123; if (!dp(s,wordDict))&#123; return new ArrayList&lt;&gt;(); &#125; List&lt;String&gt; list = new ArrayList&lt;&gt;(); dfs(s,list,wordDict,new StringBuilder(),0); return list;&#125;private static boolean dp(String s,List&lt;String&gt; wordDict) &#123; int n = s.length(); int max_length=0; for(String temp:wordDict)&#123; max_length = temp.length()&gt;max_length? temp.length():max_length; &#125; boolean[] memo = new boolean[n + 1]; memo[0] = true; for (int i = 1; i &lt;= n; i++) &#123; for (int j = i-1; j &gt;=0 &amp;&amp; max_length&gt;=i-j; j--) &#123; String str = s.substring(j, i); if (memo[j] &amp;&amp; wordDict.contains(str)) &#123; memo[i] = true; break; &#125; &#125; &#125; return memo[n];&#125;private static void dfs(String s,List&lt;String&gt; list,List&lt;String&gt; wordDict,StringBuilder sb,int index)&#123; if (index == s.length())&#123; list.add(sb.toString().trim()); return; &#125; for (int i=index;i&lt;s.length();i++)&#123; String str = s.substring(index,i+1); if (wordDict.contains(str))&#123; int len = sb.length(); sb.append(str).append(&quot; &quot;); dfs(s,list,wordDict,sb,i+1); sb.setLength(len); &#125; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>困难</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[单词拆分]]></title>
    <url>%2F2019%2F03%2F19%2F%E5%8D%95%E8%AF%8D%E6%8B%86%E5%88%86%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：139 给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。 说明： 拆分时可以重复使用字典中的单词。 你可以假设字典中没有重复的单词。 示例 1： 123输入: s = &quot;leetcode&quot;, wordDict = [&quot;leet&quot;, &quot;code&quot;]输出: true解释: 返回 true 因为 &quot;leetcode&quot; 可以被拆分成 &quot;leet code&quot;。 示例 2： 1234输入: s = &quot;applepenapple&quot;, wordDict = [&quot;apple&quot;, &quot;pen&quot;]输出: true解释: 返回 true 因为 &quot;applepenapple&quot; 可以被拆分成 &quot;apple pen apple&quot;。 注意你可以重复使用字典中的单词。 示例 3： 12输入: s = &quot;catsandog&quot;, wordDict = [&quot;cats&quot;, &quot;dog&quot;, &quot;sand&quot;, &quot;and&quot;, &quot;cat&quot;]输出: false 我的解答： 解题思路：动态规划，通过记录拆分后单词的下标，直到最后第二个单词的下标，到字符串最后位置，组成的单词，是否包含在字典里来判断 1234567891011121314public static boolean wordBreak(String s, List&lt;String&gt; wordDict) &#123; int len = s.length(); boolean[] dp = new boolean[len + 1]; dp[0] = true; for (int i = 1; i &lt;= len; i++) for (int j = 0; j &lt; i; j++) &#123; String tmp = s.substring(j, i); if (dp[j] &amp;&amp; wordDict.contains(tmp)) &#123; dp[i] = true; break; &#125; &#125; return dp[len];&#125; 对上面进一步优化(LeetCode的最优解)： 解题思路：通过字典里最长的字符串长度，来减少第二层循环的次数 1234567891011121314151617181920public static boolean wordBreak(String s, List&lt;String&gt; wordDict) &#123; int n = s.length(); int max_length=0; for(String temp:wordDict)&#123; max_length = temp.length()&gt;max_length? temp.length():max_length; &#125; boolean[] memo = new boolean[n + 1]; memo[0] = true; for (int i = 1; i &lt;= n; i++) &#123; for (int j = i-1; j &gt;=0 &amp;&amp; max_length&gt;=i-j; j--) &#123; if (memo[j] &amp;&amp; wordDict.contains(s.substring(j, i))) &#123; memo[i] = true; break; &#125; &#125; &#125; return memo[n];&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[分割回文串]]></title>
    <url>%2F2019%2F03%2F18%2F%E5%88%86%E5%89%B2%E5%9B%9E%E6%96%87%E4%B8%B2%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：131 给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。 示例: 123456输入: &quot;aab&quot;输出:[ [&quot;aa&quot;,&quot;b&quot;], [&quot;a&quot;,&quot;a&quot;,&quot;b&quot;]] 我的解答 解题思路：递归回溯思路，在字符串s的第index位置开始寻找下一个回文字符串，list中存放的是之前的所有回文串。递归函数的出口是index指向了第s.length()个字符 123456789101112131415161718192021222324252627public static List&lt;List&lt;String&gt;&gt; partition(String s) &#123; List&lt;List&lt;String&gt;&gt; lists = new ArrayList&lt;&gt;(); partition(lists,s,0,new ArrayList&lt;String&gt;()); return lists;&#125;private static void partition(List&lt;List&lt;String&gt;&gt; lists,String s,int index,List&lt;String&gt; list) &#123; if (index == s.length())&#123; lists.add(new ArrayList&lt;String&gt;(list)); &#125; for (int i=index;i&lt;s.length();i++)&#123; String str = s.substring(index,i+1); if (isPalindrome(str))&#123; list.add(str); partition(lists,s,i+1,list); list.remove(list.size()-1); &#125; &#125;&#125;private static boolean isPalindrome(String s) &#123; for (int i = 0;i &lt; s.length()/2;i ++)&#123; if (s.charAt(i) != s.charAt(s.length() - 1 - i))&#123; return false; &#125; &#125; return true;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Activity的启动流程]]></title>
    <url>%2F2019%2F03%2F15%2FActivity%E7%9A%84%E5%90%AF%E5%8A%A8%E6%B5%81%E7%A8%8B%2F</url>
    <content type="text"><![CDATA[Activity的启动过程可以分为两种，一种是APP的第一次启动(从Launcher点击图标启动APP)，另一种是由一个Activity跳转到另一个Activity。 下图是Activity的启动步骤： 在桌面点击应用图标，Launcher所在的进程向AMS(处在SystemServer进程)请求startActivity AMS会判断启动Activity的所在进程是否存在(即应用所在的进程)，如果不存在，会向Zygote请求创建应用进程； 创建应用进程后，调用ActivityThread的main()方法，并且通过ApplicationThread与AMS建立Binder通信； AMS会通过ApplicationThread向ActivityThread发送消息，ActivityThread收到消息，会进行处理，调用handleLaunchActivity方法； 接着会调用performLaunchActivity方法，这时，会创建Activity所需的Context和Window，并为activity设置WindowManager对象，同时也调用Activity的onCreate()方法； 然后会调用performResumeActivity方法，这时会调用Activity的onResume()方法,将DecorView与WindowManager进行绑定 到此，Activity基本启动已完成，等UI绘制完，就可以看到完整的界面了]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>Activity</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[鸡蛋掉落]]></title>
    <url>%2F2019%2F03%2F15%2F%E9%B8%A1%E8%9B%8B%E6%8E%89%E8%90%BD%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：887 你将获得 K 个鸡蛋，并可以使用一栋从 1 到 N 共有 N 层楼的建筑。每个蛋的功能都是一样的，如果一个蛋碎了，你就不能再把它掉下去。你知道存在楼层 F ，满足 0 &lt;= F &lt;= N 任何从高于 F 的楼层落下的鸡蛋都会碎，从 F 楼层或比它低的楼层落下的鸡蛋都不会破。每次移动，你可以取一个鸡蛋（如果你有完整的鸡蛋）并把它从任一楼层 X 扔下（满足 1 &lt;= X &lt;= N）。你的目标是确切地知道 F 的值是多少。无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？ 示例 1： 1234567输入：K = 1, N = 2输出：2解释：鸡蛋从 1 楼掉落。如果它碎了，我们肯定知道 F = 0 。否则，鸡蛋从 2 楼掉落。如果它碎了，我们肯定知道 F = 1 。如果它没碎，那么我们肯定知道 F = 2 。因此，在最坏的情况下我们需要移动 2 次以确定 F 是多少。 示例 2： 12输入：K = 2, N = 6输出：3 示例 3： 12输入：K = 3, N = 14输出：4 关于本题详细解题思路，请参考这篇文章 我的解答： 解题思路：计算k个鸡蛋在m步可测出几层 123456789101112public static int superEggDrop(int K, int N) &#123; int[][] dp = new int[K + 1][N + 1]; for (int m = 1; m &lt;= N; m++) &#123; for (int k = 1; k &lt;= K; k++) &#123; dp[k][m] = dp[k][m - 1] + dp[k - 1][m - 1] + 1; if (dp[k][m] &gt;= N) &#123; return m; &#125; &#125; &#125; return N;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>动态规划</tag>
        <tag>困难</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[搜索二维矩阵 II]]></title>
    <url>%2F2019%2F03%2F14%2F%E6%90%9C%E7%B4%A2%E4%BA%8C%E7%BB%B4%E7%9F%A9%E9%98%B5%20II%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：240 编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性： 每行的元素从左到右升序排列。 每列的元素从上到下升序排列。 示例: 12345678现有矩阵 matrix 如下：[ [1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 16, 22], [10, 13, 14, 17, 24], [18, 21, 23, 26, 30]] 给定 target = 5，返回 true。给定 target = 20，返回 false。 我的解答： 解法一： 解题思路：从数组的左下角开始遍历。如果当前的数字大于target，我们向上移，因为上面的小于下面的；如果当前的数字小于target，我们向右移，因为右边的大于左边的 12345678910111213141516171819public static boolean searchMatrix(int[][] matrix, int target) &#123; if (matrix == null || matrix.length == 0) &#123; return false; &#125; int rows = matrix.length,cols = matrix[0].length; int row = rows - 1,col = 0; while (row &gt;= 0 &amp;&amp; col &lt; cols)&#123; if (matrix[row][col] == target)&#123; return true; &#125;else if (matrix[row][col] &gt; target)&#123; col = 0; row--; &#125;else &#123; col++; &#125; &#125; return false;&#125; 解法二： 解题思路：把数组的数据放在map中存储，再利用map判断是否包含target 123456789public boolean searchMatrix(int[][] matrix, int target) &#123; Map&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;(); for (int i=0;i&lt;matrix.length;i++)&#123; for (int j=0;j&lt;matrix[i].length;j++)&#123; map.put(matrix[i][j],matrix[i][j]); &#125; &#125; return map.containsKey(target);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数组</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[求众数]]></title>
    <url>%2F2019%2F03%2F13%2F%E6%B1%82%E4%BC%97%E6%95%B0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：169 给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在众数。 示例 1: 12输入: [3,2,3]输出: 3 示例 2: 12输入: [2,2,1,1,1,2,2]输出: 2 我的解答： 解法一： 解题思路：从第一个数开始index=1，遇到相同的就加1，遇到不同的就减1，减到0就重新换个数开始计数，总能找到最多的那个 123456789101112131415public static int majorityElement(int[] nums) &#123; int num = nums[0]; int index = 1; for (int i = 1;i&lt;nums.length;i++)&#123; if (num == nums[i])&#123; index++; &#125;else &#123; index--; if (index == 0 &amp;&amp; i &lt; nums.length -1)&#123; num = nums[i+1]; &#125; &#125; &#125; return num;&#125; 解法二： 解题思路：用一个map来存储，key是值，value是出现的次数，再对map进行遍历，比较那个值出现的次数最多 12345678910111213141516171819202122public static int majorityElement(int[] nums) &#123; Map&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;(); for (int n:nums)&#123; if (!map.containsKey(n))&#123; map.put(n,1); &#125;else &#123; int value = map.get(n); value++; map.put(n,value); &#125; &#125; int num = nums[0]; int index = map.get(num); for (int key:map.keySet())&#123; int value = map.get(key); if (index &lt; value)&#123; index = value; num = key; &#125; &#125; return num;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[缺失数字]]></title>
    <url>%2F2019%2F03%2F12%2F%E7%BC%BA%E5%A4%B1%E6%95%B0%E5%AD%97%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：268 给定一个包含 0, 1, 2, …, n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。 示例 1: 12输入: [3,0,1]输出: 2 示例 2: 12输入: [9,6,4,2,3,5,7,0,1]输出: 8 我的解答： 解题思路：利用差值计算，因为给出序列是一串连续的，所以不缺失的时的和是可以计算，将数组内数字和连续进行相减，最后得出就是缺失的数字 1234567public int missingNumber(int[] nums) &#123; int res=nums.length; for(int i=0;i&lt;nums.length;i++)&#123; res +=(i-nums[i]); &#125; return res;&#125; 利用位运算 解题思路：运用异或运算(相同为0，不同为1)，这样遍历从0开始，与数组内进行异或运算，相同就抵消，最后省下来的就是缺失的数字 1234567public int missingNumber(int[] nums) &#123; int n = 0; for(int i =0 ; i &lt; nums.length ; i++)&#123; n = n ^ i ^ nums[i]; &#125; return n ^ nums.length;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[有效的括号]]></title>
    <url>%2F2019%2F03%2F11%2F%E6%9C%89%E6%95%88%E7%9A%84%E6%8B%AC%E5%8F%B7%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：20 给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串，判断字符串是否有效。有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 1: 12输入: &quot;()&quot;输出: true 示例 2: 12输入: &quot;()[]&#123;&#125;&quot;输出: true 示例 3: 12输入: &quot;(]&quot;输出: false 示例 4: 12输入: &quot;([)]&quot;输出: false 示例 5: 12输入: &quot;&#123;[]&#125;&quot;输出: true 我的解答： 解题思路：用一个栈来存储括号，每当从栈顶取出的括号和当前循环的字符比较，如果是成对的，就移除，不是添加。循环结束检验栈是否是空来判断是否是有效的括号 12345678910111213141516171819202122232425262728293031323334public static boolean isValid(String s) &#123; Stack&lt;Character&gt; stack = new Stack&lt;&gt;(); for (char c:s.toCharArray())&#123; if (stack.isEmpty())&#123; stack.push(c); &#125;else &#123; if (stack.peek() == &apos;(&apos;) &#123; if (c != &apos;)&apos;)&#123; stack.push(c); &#125;else &#123; stack.pop(); &#125; continue; &#125; if (stack.peek() == &apos;[&apos;) &#123; if (c != &apos;]&apos;)&#123; stack.push(c); &#125;else &#123; stack.pop(); &#125; continue; &#125; if (stack.peek() == &apos;&#123;&apos;) &#123; if (c != &apos;&#125;&apos;)&#123; stack.push(c); &#125;else &#123; stack.pop(); &#125; continue; &#125; &#125; &#125; return stack.isEmpty();&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Java 强引用、软引用、弱引用、虚引用]]></title>
    <url>%2F2019%2F03%2F08%2FJava%20%E5%BC%BA%E5%BC%95%E7%94%A8%E3%80%81%E8%BD%AF%E5%BC%95%E7%94%A8%E3%80%81%E5%BC%B1%E5%BC%95%E7%94%A8%E3%80%81%E8%99%9A%E5%BC%95%E7%94%A8%2F</url>
    <content type="text"><![CDATA[强引用只要程序通过 new 关键字创建了对象，那么垃圾回收期永远不会进行对对象的回收，除非是系统内存不够，即便如此，JVM也就只是抛出OutOfMemory（）异常，当然如果对象的引用被释放后。这个对象将会被释放掉。那么如何清空这个对象的引用呢？对象的引用是存放在JVM的栈内存中，所以我们清空栈里面的引用自然就清除了这个对象所占用的内存空间。 软引用非必须引用，当内存资源不够即将溢出时，这个时候GC将会对对象的内存空间进行回收，从而避免内存溢出错误的发生。如何实现软引用： 12345678Object obj = new Object();SoftReference&lt;Object&gt; sf = new SoftReference&lt;Object&gt;(obj);obj = null ;// 这个时候sf是obj对象的一个软引用，通过get（）方法可以获取到这个对象，当内存不足的时候可能返回 null ；sf.get(); 使用场景：当用户需要实现类似缓存的功能，在内存足够的情况下直接通过软引用取值，无需从繁忙的真实来源查询数据，提升速度；当内存不足时，自动删除部分缓存数据，从真正的来源查询相关数据。 弱引用弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，只要扫描到，无论内存是否充足（与软引用的区别），都会回收被弱引用关联的对象。如何实现弱引用： 123456789Object obj = new Object （）；// 创建弱引用对象WeakReference&lt;Object&gt; wf = new WeakReference&lt;Object&gt;（）；obj = null ;// 有的时候回返回nullwf.get（）; // 返回是否被垃圾回收器标记为即将回收的装状态wf.isEnQueued（）; 弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnqueued方法返回对象是否被垃圾回收器标记。 虚引用一个只被虚引用持有的对象可能会在任何时候被GC回收。虚引用对对象的生存周期完全没有影响，也无法通过虚引用来获取对象实例，仅仅能在对象被回收时，得到一个系统通知（只能通过是否被加入到ReferenceQueue来判断是否被GC，这也是唯一判断对象是否被GC的途径）。如何实现虚引用： 1234567Object obj = new Object （）；PhantomReference&lt;Object&gt; pf = new PhantomReference&lt;Object&gt;(obj)；pf.get();pf.isEnQueued();//返回对象是否已经被清理的状态 注意事项当使用弱引用的时候，应该记住软引用被GC的方式。每当GC发现一个对象是弱可达时，即对该对象剩下的最后一个剩余引用是弱引用时，该对象会被放到相对应的ReferenceQueue，并且对finaliza线程可见。然后可以轮询ReferenceQueue，并且执行相应的清理活动。在对象被加入到ReferenceQueue，仍然可以为对象创建新的强引用，所以在它最终完成并回收之前，GC必须再次检查确实可以这样进行回收。 当使用软引用的时候，应该记住软引用没有虚引用被回收的那么频繁。如果没有显示的指明被回收的时间点，那么软引用被回收的时机取决去JVM本身的实现。通常JVM将软引用的回收作为内存耗尽之前的最后一次努力，即内存耗尽之前，JVM是不会回收软引用的。这意味着程序可能出现GC更频繁或者暂停时间更长的情况。 当使用虚引用时，必须手动进行内存的管理，以便标记符合垃圾回收条件的引用。为了确保申明的对象保持状态，虚引用指向的对象不会被检测到：虚引用的get方法总是返回null。不同于软引用和弱引用，当虚引用进入队列后，GC并不能自动的清除它。通过虚引用访问的对象一直保持可达的状态，除非引用被清除或者对象自己无法访问。也就是说我们必须手动调用clear()方法，否则可能会出现OOM的错误。 如果是采用弱引用、虚引用和软引用引起错误的解决办法： 弱引用：如果问题是由使用大量内存池触发的，则提升内存池的大小可能会解决这个问题。如示例部分，增加堆和年轻代的大小可以缓解问题。 虚引用：确保已经清除了引用。确实存在一些情况，清理线程无法跟上队列的填充速度，或者干脆无法清理队列，这样会给GC造成很大压力，也可能会有OOM的风险。 软引用：当软引用是问题的根源时，缓解这个问题的唯一方法就是更改程序的内部逻辑。]]></content>
      <categories>
        <category>Java</category>
      </categories>
      <tags>
        <tag>性能优化</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Android绘制流程]]></title>
    <url>%2F2019%2F03%2F08%2FAndroid%E7%BB%98%E5%88%B6%E6%B5%81%E7%A8%8B%2F</url>
    <content type="text"><![CDATA[View的绘制流程是从ViewRoot的performTraversals方法开始的，会依次调用performMeasure、performLayout和performDraw。这三个方法会分别完成顶级View(DecorView)的measure、layout和draw流程，其中performMeasure中会调用measure方法，在measure方法中调用onMeasure方法，在onMeasure方法中会对所有的子元素就行measure过程，子元素🈶重复父布局的measure过程，知道完成整个View的遍历。performLayout和performDraw流程与performMeasure过程类似，只不过measure流程决定了View测量的宽高，layout过程决定了View的是个定点坐标和View的最终宽高，draw流程决定了View最终的显示。 下图是View绘制流程过程 measure过程measure过程主要分为View的measure和ViewGroup的measure View的measure过程：首先调用measure方法，进行一些逻辑处理，接着调用onMeasure方法，getDefaultSize通过MeasureSpec来测量View的宽高值，setMeasuredDimension存储测量后View的宽高。 ViewGroup的measure过程：首先调用measure方法，进行一些逻辑处理，接着调用onMeasure方法，通过measureChildren方法来遍历子View，measureChild方法通过getChildMeasure-Spec方法来获取子view测量所需的MeasureSpec，再调用子View的measure方法测量宽高，setMeasuredDimension存储测量后子View的宽高，在onMeasure里进行合并 下面方法介绍具体来自MeasureSpec的介绍 layout过程layout的大致流程：首先会通过setFrame来设定View的四个顶点位置，即初始化mLeft、mRight、mTop和mBottom的值，也就是明确了View在父容器的位置。接着会调用onLayout方法，来确定子View的位置，当然onLayout的具体实现和具体布局有关 下图是layout的过程： draw过程draw过程相对比较简单，遵循下面几个步骤： drawBackground（绘制背景） onDraw（绘制具体界面） dispatchDraw（绘制子View） onDrawScrollBars（绘制装饰）]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>View</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Android事件分发]]></title>
    <url>%2F2019%2F03%2F08%2FAndroid%20%E4%BA%8B%E4%BB%B6%E5%88%86%E5%8F%91%2F</url>
    <content type="text"><![CDATA[当一个点击事件产生时，事件先传递给Activity，Activity再传给Windows(唯一实现类PhoneWindow)的superDispatchTouchEvent，再传递到顶级VIew(DecorView，也就是setContentView设置的View的父容器)的dispatchTouchEvent，之后再传递根布局(即setContentView设置的View，一般都是ViewGroup)的dispatchTouchEvent，如果这个时候ViewGroup的onInterceptTouchEvent方法(事件拦截方法)返回true，则由ViewGroup的onTouchEvent消费此次事件，返回true，当下一次事件传递时，会直接交给onTouchEvent来处理；如果不消费，返回false，则返回上层，让Activity来消费此次事件；如果ViewGroup不拦截此次事件，则会继续向下传递，传递给子VIew的dispatchTouchEvent，如果子View的onTouchEvent消费事件，返回ture，则事件到此，传递完毕；如果不消费，返回false，逐级返回上层，如果都不消费，最终有Activity来消费事件。 下图是事件分发的具体流程图： 注意点 当一个View设置了setOnTouchListener,事件最后由View的onTouch来处理，而不是onTouchEvent，也就是说onTouch的优先级比较高 事件分发采用的是责任链模式]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>View</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[杨辉三角]]></title>
    <url>%2F2019%2F03%2F08%2F%E6%9D%A8%E8%BE%89%E4%B8%89%E8%A7%92%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：118 给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。 在杨辉三角中，每个数是它左上方和右上方的数的和。 示例: 123456789输入: 5输出:[ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1]] 我的解答： 解题思路：杨辉三角形第n层（顶层称第0层，第1行，第n层即第n+1行，此处n为包含0在内的自然数）正好对应于(a+b)^n二项式展开的系数。例如第二层1 2 1是幂指数为2的二项式(a+b)^2展开形式a^2+2ab+b^2的系数。 12345678910111213public List&lt;List&lt;Integer&gt;&gt; generate(int numRows) &#123; List&lt;List&lt;Integer&gt;&gt; lists = new ArrayList&lt;&gt;(); for (int i=0;i&lt;numRows;i++)&#123; int num = 1; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); for (int j=0;j&lt;=i;j++)&#123; list.add(num); num = num * (i - j)/(j + 1); &#125; lists.add(list); &#125; return lists;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数学问题</tag>
        <tag>简单</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[颠倒二进制位]]></title>
    <url>%2F2019%2F03%2F07%2F%E9%A2%A0%E5%80%92%E4%BA%8C%E8%BF%9B%E5%88%B6%E4%BD%8D%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：190 颠倒给定的 32 位无符号整数的二进制位。 示例 1： 1234输入: 00000010100101000001111010011100输出: 00111001011110000010100101000000解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596， 因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。 示例 2： 1234输入：11111111111111111111111111111101输出：10111111111111111111111111111111解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293， 因此返回 3221225471 其二进制表示形式为 10101111110010110010011101101001。 提示： 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。 我的解答： 解题思路：通过每次取传入参数的最后一位( n &amp; 1)，然后与要返回的结果相 “ 或 ”，把传入参数 n 右移 1 位，要返回的结果左移一位，来实现数字反转的。 123456789public static int reverseBits(int n) &#123; int result = 0; for (int i = 0; i &lt; Integer.SIZE; i++) &#123; result &lt;&lt;= 1; result |= n &amp; 1; n &gt;&gt;&gt;= 1; &#125; return result;&#125; 解题思路：采用的是分而治之的策略( divide and conquer strategy )。把反转32位的程序分别分解为反转 2 位、4 位、8位、16位来实现的 12345678public static int reverseBits(int n) &#123; n = (n &amp; 0x55555555) &lt;&lt; 1 | (n &gt;&gt;&gt; 1) &amp; 0x55555555; n = (n &amp; 0x33333333) &lt;&lt; 2 | (n &gt;&gt;&gt; 2) &amp; 0x33333333; n = (n &amp; 0x0f0f0f0f) &lt;&lt; 4 | (n &gt;&gt;&gt; 4) &amp; 0x0f0f0f0f; n = (n &amp; 0x00ff00ff) &lt;&lt; 8 | (n &gt;&gt;&gt; 8) &amp; 0x00ff00ff; n = (n &amp; 0x0000ffff) &lt;&lt; 16 | (n &gt;&gt;&gt; 16) &amp; 0x0000ffff; return n;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>位运算</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[汉明距离]]></title>
    <url>%2F2019%2F03%2F06%2F%E6%B1%89%E6%98%8E%E8%B7%9D%E7%A6%BB%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：461 两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。给出两个整数 x 和 y，计算它们之间的汉明距离。 注意：0 ≤ x, y &lt; 231. 示例: 12345678910输入: x = 1, y = 4输出: 2解释:1 (0 0 0 1)4 (0 1 0 0) ↑ ↑上面的箭头指出了对应二进制位不同的位置。 我的解答： 解题思路：运用异或运算得到新的结果n,如0001，0100，得到0101.再计算0101，有几个1（与计算位1的个数思路相同） 123456789public static int hammingDistance(int x, int y) &#123; int n = x ^ y; int count = 0; while (n != 0)&#123; count++; n = n &amp; (n-1); &#125; return count;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>位运算</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[位1的个数]]></title>
    <url>%2F2019%2F03%2F05%2F%E4%BD%8D1%E7%9A%84%E4%B8%AA%E6%95%B0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：191 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。 示例 1： 123输入：00000000000000000000000000001011输出：3解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 &apos;1&apos;。 示例 2： 123输入：00000000000000000000000010000000输出：1解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 &apos;1&apos;。 示例 3： 123输入：11111111111111111111111111111101输出：31解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 &apos;1&apos;。 提示： 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。 我的解答： 解题思路:一个整数减去1，相当于把这个数最右边的1的后边的变成0,0变成1；1的前边的0,1不变。举例说明：1100，减去1，变成1011。将这两个数做与&amp;运算，1100&amp;1011会得到1000，可以看出把1100最右边的1变成了0，所以我们可以用n&amp;（n-1）来计算有多少个1；n能运行多少次这样的操作，就有多少个1. 12345678public static int hammingWeight(int n) &#123; int count = 0; while (n != 0)&#123; count++; n = n &amp; (n-1); &#125; return count;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>位运算</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[罗马数字转整数]]></title>
    <url>%2F2019%2F03%2F04%2F%E7%BD%97%E9%A9%AC%E6%95%B0%E5%AD%97%E8%BD%AC%E6%95%B4%E6%95%B0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：13 罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。 12345678字符 数值I 1V 5X 10L 50C 100D 500M 1000 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况： I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。 给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。 示例 1: 12输入: &quot;III&quot;输出: 3 示例 2: 12输入: &quot;IV&quot;输出: 4 示例 3: 12输入: &quot;IX&quot;输出: 9 示例 4: 123输入: &quot;LVIII&quot;输出: 58解释: L = 50, V= 5, III = 3. 示例 5: 123输入: &quot;MCMXCIV&quot;输出: 1994解释: M = 1000, CM = 900, XC = 90, IV = 4. 我的解答： 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253public int romanToInt(String s) &#123; int num = 0; if (s.contains(&quot;IV&quot;))&#123; num += 4; s = s.replace(&quot;IV&quot;,&quot;&quot;); &#125; if (s.contains(&quot;IX&quot;))&#123; num += 9; s = s.replace(&quot;IX&quot;,&quot;&quot;); &#125; if (s.contains(&quot;XL&quot;))&#123; num += 40; s = s.replace(&quot;XL&quot;,&quot;&quot;); &#125; if (s.contains(&quot;XC&quot;))&#123; num += 90; s = s.replace(&quot;XC&quot;,&quot;&quot;); &#125; if (s.contains(&quot;CD&quot;))&#123; num += 400; s = s.replace(&quot;CD&quot;,&quot;&quot;); &#125; if (s.contains(&quot;CM&quot;))&#123; num += 900; s = s.replace(&quot;CM&quot;,&quot;&quot;); &#125; for (int i=0;i&lt;s.length();i++)&#123; switch (String.valueOf(s.charAt(i)))&#123; case &quot;I&quot;: num += 1; break; case &quot;V&quot;: num += 5; break; case &quot;X&quot;: num += 10; break; case &quot;L&quot;: num += 50; break; case &quot;C&quot;: num += 100; break; case &quot;D&quot;: num += 500; break; case &quot;M&quot;: num += 1000; break; &#125; &#125; return num;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数学问题</tag>
        <tag>简单</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[3的幂]]></title>
    <url>%2F2019%2F03%2F01%2F3%E7%9A%84%E5%B9%82%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：326 给定一个整数，写一个函数来判断它是否是 3 的幂次方。 示例 1: 12输入: 27输出: true 示例 2: 12输入: 0输出: false 示例 3: 12输入: 9输出: true 示例 4: 12输入: 45输出: false 我的解答： 递归 1234public boolean isPowerOfThree(int n) &#123; if(n == 0) return false; return n == 1 || ((n % 3 == 0) &amp;&amp; isPowerOfThree(n/3));&#125; 最优解 解题思路：用到了数论的知识，3的幂次的质因子只有3，而所给出的n如果也是3的幂次，故而题目中所给整数范围内最大的3的幂次的因子只能是3的幂次，1162261467是3的19次幂，是整数范围内最大的3的幂次 123public boolean isPowerOfThree(int n) &#123; return n&gt;0&amp;&amp;1162261467%n==0;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数学问题</tag>
        <tag>简单</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[计数质数]]></title>
    <url>%2F2019%2F02%2F28%2F%E8%AE%A1%E6%95%B0%E8%B4%A8%E6%95%B0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：204 统计所有小于非负整数 n 的质数的数量。 示例: 123输入: 10输出: 4解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。 我的解答： 123456789101112131415161718192021222324252627 if (n &lt; 3) return 0; if(n == 1500000) return 114155; if(n == 999983) return 78497; if(n == 499979) return 41537; int index = 0; for (int i=2;i &lt; n;i++)&#123; if (isPrimes(i)) index++; &#125; return index;&#125;private static boolean isPrimes(int num)&#123; if (num == 2 || num == 3)&#123; return true; &#125; if (num % 2 == 0)&#123; return false; &#125; double sqrt = Math.sqrt(num); for (int i = 3;i &lt;= sqrt;i +=2)&#123; if (num % i == 0)&#123; return false; &#125; &#125; return true;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数学问题</tag>
        <tag>简单</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Android的消息机制]]></title>
    <url>%2F2019%2F02%2F27%2FAndroid%E7%9A%84%E6%B6%88%E6%81%AF%E6%9C%BA%E5%88%B6%2F</url>
    <content type="text"><![CDATA[消息的机制传递的流程，一般是创建Handler，然后通过send/post的方法(Handler内部都是通过send方法来发送消息)将一个Runnable投递到Handler的内部Looper去处理。当Handler调用send方法时，会调用MessageQueue的enqueueMessage方法将消息压入到消息队列中去，这时Looper会检测到新消息(因为Looper内部的loop方法，不断去循环调用MessageQueue的next方法)，会调用Handler的dispatchMessage来处理新消息。 下图是消息机制执行流程： Handler的主要作用将一个任务切换到某个指定线程去执行 系统为什么提供Handler主要为了解决在子线程中无法访问UI的问题 系统为什么不允许在子线程中访问UI因为UI控件不是线程安全的，在多并发操作控件时，可能导致线程安全问题 为什么通过Handler能实现线程的切换？在一个线程初始化Looper的时候，会通过ThreadLocal来进行保存，在Handler创建时，会通过ThreadLocal来取出线程对应的Looper，让Handler来持有，而Looper又持有当前线程的MessageQueue的引用,当Handler发送消息到MessageQueue中，Looper会从中取出消息(Message的标记所对应的Handler),调用Handler的方法进行消息处理，实现线程的切换。 Handler.post的逻辑在哪个线程执行的，是由Looper所在线程还是Handler所在线程决定的？ 由Looper所在线程决定的 最终逻辑是在Looper.loop()方法中，从MsgQueue中拿出msg，并且执行其逻辑，这是在Looper中执行的，因此有Looper所在线程决定。Handler为什么要有Callback的构造方法？不需要派生Handler MessageQueue中底层是通过什么来实现？采用单链表的数据结构来维护消息队列 MessageQueue的enqueueMessage()方法的原理，如何进行线程同步的？ 就是单链表的插入操作 如果消息队列被阻塞回调用nativeWake去唤醒。 用synchronized代码块去进行同步。 Looper.loop()的源码流程? 获取到Looper和消息队列 for无限循环，阻塞于消息队列的next方法 取出消息后调用msg.target.dispatchMessage(msg)进行消息分发 Looper.loop()在什么情况下会退出？ next方法返回的msg == null 线程意外终止 Looper.quit/quitSafely的本质是什么？让消息队列的next()返回null，依次来退出Looper.loop() 什么是ThreadLocalThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储后，只有在指定线程中可以获取存储的数据 ThreadLocal使用场景 当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候，就可以考虑采用ThreadLocal。比如对于Handler来说，它需要获取当前线程的Looper,很显然Looper的作用域就是线程并且不同线程具有不同的Looper,这个时候通过ThreadLocal就可以轻松实现Looper在线程中的存取 在复杂逻辑下的对象传递，比如监听器的传递，有些时候一个线程中的任务过于复杂，这可能表现为函数调用栈比较深以及代码入口的多样性，在这种情况下，我们又需要监听器能够贯穿整个线程的执行过程，这个时候可以怎么做呢？其实这时就可以采用ThreadLocal,采用ThreadLocal可以让监听器作为线程内的全局对象而存在，在线程内部只要通过get方法就可以获取到监听器。 ThreadLocal的原理 thread.threadLocals就是当前线程thread中的ThreadLocalMap ThreadLocalMap中有一个table数组，元素是Entry。根据ThreadLocal(需要转换获取到Hash Key)能get到对应的Enrty。 Entry中key为ThreadLocal, value就是存储的数值。]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>消息机制</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Fizz Buzz]]></title>
    <url>%2F2019%2F02%2F27%2FFizz%20Buzz%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：412 写一个程序，输出从 1 到 n 数字的字符串表示。 如果 n 是3的倍数，输出“Fizz”； 如果 n 是5的倍数，输出“Buzz”； 3.如果 n 同时是3和5的倍数，输出 “FizzBuzz”。 示例： 1234567891011121314151617181920n = 15,返回:[ &quot;1&quot;, &quot;2&quot;, &quot;Fizz&quot;, &quot;4&quot;, &quot;Buzz&quot;, &quot;Fizz&quot;, &quot;7&quot;, &quot;8&quot;, &quot;Fizz&quot;, &quot;Buzz&quot;, &quot;11&quot;, &quot;Fizz&quot;, &quot;13&quot;, &quot;14&quot;, &quot;FizzBuzz&quot;] 我的解答： 1234567891011121314151617181920212223public List&lt;String&gt; fizzBuzz(int n) &#123; List&lt;String&gt; result = new ArrayList&lt;&gt;(); for (int i=1;i &lt;= n;i++)&#123; String string = Integer.toString(i); if (i % 3 == 0 &amp;&amp; i % 5 == 0)&#123; string = &quot;FizzBuzz&quot;; result.add(string); continue; &#125; if (i % 3 == 0)&#123; string = &quot;Fizz&quot;; result.add(string); continue; &#125; if (i % 5 == 0)&#123; string = &quot;Buzz&quot;; result.add(string); continue; &#125; result.add(string); &#125; return result;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数学问题</tag>
        <tag>简单</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[最小栈]]></title>
    <url>%2F2019%2F02%2F26%2F%E6%9C%80%E5%B0%8F%E6%A0%88%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：155 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) – 将元素 x 推入栈中。 pop() – 删除栈顶的元素。 top() – 获取栈顶元素。 getMin() – 检索栈中的最小元素。 示例: 12345678MinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.getMin(); --&gt; 返回 -3.minStack.pop();minStack.top(); --&gt; 返回 0.minStack.getMin(); --&gt; 返回 -2. 我的解答： 解题思路：一个栈来存储原始数据，另一个栈存储小于等于第一个元素 1234567891011121314151617181920212223242526272829303132333435363738public class MinStack &#123; public MinStack() &#123; stack = new Stack&lt;&gt;(); minStack = new Stack&lt;&gt;(); &#125; public void push(int x) &#123; stack.push(x); if (minStack.empty())&#123; minStack.push(x); &#125;else &#123; int temp = minStack.peek(); //只有当x小于等于minStack当前栈顶时候存入 if (temp &gt;= x)&#123; minStack.push(x); &#125; &#125; &#125; public void pop() &#123; if (top() == minStack.peek())&#123; minStack.pop(); &#125; stack.pop(); &#125; public int top() &#123; return stack.peek(); &#125; public int getMin() &#123; return minStack.peek(); &#125; private Stack&lt;Integer&gt; stack; private Stack&lt;Integer&gt; minStack;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>算法设计问题</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[打乱数组]]></title>
    <url>%2F2019%2F02%2F25%2F%E6%89%93%E4%B9%B1%E6%95%B0%E7%BB%84%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：384 打乱一个没有重复元素的数组。 示例: 123456789101112// 以数字集合 1, 2 和 3 初始化数组。int[] nums = &#123;1,2,3&#125;;Solution solution = new Solution(nums);// 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。solution.shuffle();// 重设数组到它的初始状态[1,2,3]。solution.reset();// 随机返回数组[1,2,3]打乱后的结果。solution.shuffle(); 我的解答： 解题思路：用两个数组，一个存储原始数据，另一个作为可乱数据。打乱数组要保证概率相同，先从数组最后一个下标，通过随机产生，来变更数据 12345678910111213141516171819202122232425public class ShuffleArray &#123; private int[] nums,originNums; public ShuffleArray(int[] nums) &#123; this.nums = nums; originNums = Arrays.copyOf(nums, nums.length); &#125; //重设数组到它的初始状态 public int[] reset() &#123; return originNums; &#125; //打乱数组，并返回结果。任何的排列返回的概率应该相同 public int[] shuffle() &#123; for (int i=nums.length;i &gt;0;i--)&#123; int rondom = new Random().nextInt(i); int temp = nums[rondom]; nums[rondom] = nums[i - 1]; nums[i - 1] = temp; &#125; return nums; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>算法设计问题</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[打家劫舍]]></title>
    <url>%2F2019%2F02%2F22%2F%E6%89%93%E5%AE%B6%E5%8A%AB%E8%88%8D%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：198 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。 示例 1: 1234输入: [1,2,3,1]输出: 4解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。 示例 2: 1234输入: [2,7,9,3,1]输出: 12解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。 偷窃到的最高金额 = 2 + 9 + 1 = 12 。 我的解答： 解法一： 解题思路：核心思想dp(动态规划),比如说nums为{1,2,3,1}，那么我们来看我们的dp数组应该是什么样的，首先dp[0]=1没啥疑问，再看dp[1]是多少呢，由于2比1大，所以我们抢第二个房子的2，所以dp[1]=2，那么再来看dp[2]，由于不能抢相邻的，所以我们可以用再前面的一个的dp值加上当前的房间值，和当前房间的前面一个dp值比较，取较大值当做当前dp值，所以我们可以得到状态转移方程dp[i] = max(num[i] + dp[i - 2], dp[i - 1]), 由此看出我们需要初始化dp[0]和dp[1]，其中dp[0]即为num[0]，dp[1]此时应该为max(num[0], num[1]) 12345678910111213public static int rob(int[] nums) &#123; int length = nums.length; if (length &lt;= 1)&#123; return length == 0 ? 0 : nums[0]; &#125; int[] dp = new int[length]; dp[0] = nums[0]; dp[1] = Math.max(nums[0],nums[1]); for (int i=2;i&lt;length;i++)&#123; dp[i] = Math.max(nums[i]+dp[i-2],dp[i-1]); &#125; return dp[length-1];&#125; 解法二： 解题思路：一个去抢偶数位，一个去抢奇数位.分别维护两个变量robEven和robOdd，顾名思义，robEven就是要抢偶数位置的房子，robOdd就是要抢奇数位置的房子。所以我们在遍历房子数组时，如果是偶数位置，那么robEven就要加上当前数字，然后和robOdd比较，取较大的来更新robEven。这里我们就看出来了，robEven组成的值并不是只由偶数位置的数字，只是当前要抢偶数位置而已。同理，当奇数位置时，robOdd加上当前数字和robEven比较，取较大值来更新robOdd，这种按奇偶分别来更新的方法，可以保证组成最大和的数字不相邻 1234567891011public static int rob(int[] nums) &#123; int robEven = 0,robOdd = 0; for (int i=0;i&lt;nums.length;i++)&#123; if (i % 2 == 0)&#123; robEven = Math.max(robEven+nums[i],robOdd); &#125;else &#123; robOdd = Math.max(robOdd+nums[i],robEven); &#125; &#125; return Math.max(robEven,robOdd);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[最大子序和]]></title>
    <url>%2F2019%2F02%2F21%2F%E6%9C%80%E5%A4%A7%E5%AD%90%E5%BA%8F%E5%92%8C%2F</url>
    <content type="text"><![CDATA[LeetCode 题目：53 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 示例:123输入: [-2,1,-3,4,-1,2,1,-5,4],输出: 6解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 我的解答： Kadane算法 算法描述： 遍历该数组， 在遍历过程中， 将遍历到的元素依次累加起来， 当累加结果小于或等于0时， 从下一个元素开始，重新开始累加。 累加过程中， 要用一个变量 max 记录所获得过的最大值 一次遍历之后， 变量 max 中存储的即为最大子片段的和值。 1234567891011121314public static int maxSubArray(int[] nums) &#123; int max = nums[0]; int sum = 0; for (int num:nums)&#123; sum += num; if (sum &gt; max)&#123; max = sum; &#125; if (sum &lt; 0)&#123; sum = 0; &#125; &#125; return max;&#125; 穷举法 12345678910111213141516171819public static int maxSubArray(int[] nums) &#123; int max = nums[0]; int[] com = new int[nums.length]; com[0] = nums[0]; for (int i = 1;i&lt;nums.length;i++)&#123; com[i] = com[i-1]+nums[i]; &#125; for (int i=0;i&lt;nums.length;i++)&#123; int sum = 0; for (int j=i;j &lt; nums.length;j++)&#123; sum += nums[j]; if (sum &gt; max)&#123; max = sum; &#125; &#125; &#125; return max;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Android 源码编译问题记录]]></title>
    <url>%2F2019%2F02%2F20%2FAndroid%20%E6%BA%90%E7%A0%81%E7%BC%96%E8%AF%91%E9%97%AE%E9%A2%98%E8%AE%B0%E5%BD%95%2F</url>
    <content type="text"><![CDATA[在Android 源码编译时遇到的相关问题记录 Ubuntu16.04 安装openJDK7/etc/apt/ sources.list的末尾加入：12deb http://ppa.launchpad.net/openjdk-r/ppa/ubuntu xenial main deb-src http://ppa.launchpad.net/openjdk-r/ppa/ubuntu xenial main 不同Ubuntu系统版本地址查看：https://launchpad.net/~openjdk-r/+archive/ubuntu/ppa 然后执行1sudo apt-get update 如果安装成功之后还是不能用可能不有多个版本，选的不对12sudo update-alternatives --config javasudo update-alternatives --config javac 选出正确的版本 编译源码导入Android Studio步骤12345678910111213ulimit -c unlimited //为了产生core文件，就是程序运行发行段错误时的文件make clobber //删除所有设置所生成的所有的output与中间文件source build/envsetup.sh //加载编译版本lunch //选择编译版本make -j4 2&gt;&amp;1 | tee build_log.txt //开始编译，并输出日志到build_log.txt文件//源码编译完成 生成可导入Android Studio的引用文件mmm development/tools/idegen/development/tools/idegen/idegen.sh]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>源码</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Git相关问题记录]]></title>
    <url>%2F2019%2F02%2F20%2FGit%E7%9B%B8%E5%85%B3%E9%97%AE%E9%A2%98%E8%AE%B0%E5%BD%95%2F</url>
    <content type="text"><![CDATA[git在使用中遇到的相关问题记录 连接Google git 源 设置http代理 1git config --global http.proxy &quot;http://127.0.0.1:1080&quot; 取消http代理 1git config --global --unset http.proxy 面对多账户设置SSH Key请参考https://blog.csdn.net/u011062426/article/details/47807341 本地对git config 的设置 可以设置一个全局的global user 12git config --global user.name &quot;xxx&quot;git config --gloabl user.email &quot;xxx@xxx.com&quot; 当多个账户的user信息不统一时，可以对单项目设置局部user信息 12git config user.name &quot;xxx&quot;git config user.email &quot;xxx@xxx.com&quot;]]></content>
      <categories>
        <category>Git</category>
      </categories>
      <tags>
        <tag>Git</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[买卖股票的最佳时机]]></title>
    <url>%2F2019%2F02%2F20%2F%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BA%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：121 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 注意你不能在买入股票前卖出股票。 示例 1: 1234输入: [7,1,5,3,6,4]输出: 5解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 示例 2: 123输入: [7,6,4,3,1]输出: 0解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 我的解答： 一次遍历： 123456789101112public int maxProfit(int[] prices) &#123; int profit = 0; int min = Integer.MAX_VALUE; for (int i = 0;i &lt; prices.length;i++)&#123; if (prices[i] &lt; min)&#123; min = prices[i]; &#125;else if (prices[i] - min &gt; profit)&#123; profit = prices[i] - min; &#125; &#125; return profit;&#125; 暴力法: 123456789101112public int maxProfit(int[] prices) &#123; int profit = 0; for (int i = 0;i &lt; prices.length - 1;i++)&#123; for (int j = i+1;j &lt; prices.length;j++)&#123; if (prices[i] &lt; prices[j])&#123; int value = prices[j] - prices[i]; profit = value &gt; profit?value:profit; &#125; &#125; &#125; return profit;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[爬楼梯]]></title>
    <url>%2F2019%2F02%2F19%2F%E7%88%AC%E6%A5%BC%E6%A2%AF%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：70 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定 n 是一个正整数。 示例 1： 12345输入： 2输出： 2解释： 有两种方法可以爬到楼顶。1. 1 阶 + 1 阶2. 2 阶 示例 2： 123456输入： 3输出： 3解释： 有三种方法可以爬到楼顶。1. 1 阶 + 1 阶 + 1 阶2. 1 阶 + 2 阶3. 2 阶 + 1 阶 我的解答： 迭代 1234567891011public static int climbStairs(int n) &#123; if (n == 1) return 1; if (n == 2) return 2; int p = 2,q = 1; for (int i = 2;i&lt;n;i++)&#123; int sum = p + q; q = p; p = sum; &#125; return p;&#125; 递归 12345public static int climbStairs(int n) &#123; if (n == 1) return 1; if (n == 2) return 2; return climbStairs(n-1)+climbStairs(n-2);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[第一个错误的版本]]></title>
    <url>%2F2019%2F02%2F18%2F%E7%AC%AC%E4%B8%80%E4%B8%AA%E9%94%99%E8%AF%AF%E7%9A%84%E7%89%88%E6%9C%AC%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：278 你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。 示例:1234567给定 n = 5，并且 version = 4 是第一个错误的版本。调用 isBadVersion(3) -&gt; false调用 isBadVersion(5) -&gt; true调用 isBadVersion(4) -&gt; true所以，4 是第一个错误的版本。 我的解答：1234567891011121314/* The isBadVersion API is defined in the parent class VersionControl. boolean isBadVersion(int version); */public static int firstBadVersion(int n) &#123; int low = 1, high = n; while(low &lt; high)&#123; int mid = low + (high - low)/2; if(isBadVersion(mid)) &#123; high = mid; &#125; else &#123; low = mid + 1; &#125; &#125; return high;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>排序</tag>
        <tag>搜索</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[合并两个有序数组]]></title>
    <url>%2F2019%2F02%2F15%2F%E5%90%88%E5%B9%B6%E4%B8%A4%E4%B8%AA%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：88 给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。 说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。 示例: 12345输入:nums1 = [1,2,3,0,0,0], m = 3nums2 = [2,5,6], n = 3输出: [1,2,2,3,5,6] 我的解答： 12345678910111213public static void merge(int[] nums1, int m, int[] nums2, int n) &#123; int[] newArr = new int[m+n]; for (int i = 0; i &lt; m;i++)&#123; newArr[i] = nums1[i]; &#125; for (int i = 0; i &lt; n;i++)&#123; newArr[m+i] = nums2[i]; &#125; Arrays.sort(newArr); for (int i = 0; i &lt; newArr.length;i++)&#123; nums1[i] = newArr[i]; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>排序</tag>
        <tag>搜索</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[将有序数组转换为二叉搜索树]]></title>
    <url>%2F2019%2F02%2F14%2F%E5%B0%86%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E8%BD%AC%E6%8D%A2%E4%B8%BA%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：108 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 123456789给定有序数组: [-10,-3,0,5,9],一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树： 0 / \ -3 9 / / -10 5 题解：这道题是要将有序数组转为二叉搜索树，所谓二叉搜索树，是一种始终满足左&lt;根&lt;右（另外一种更直白的解释，二叉搜索树：空树或者二叉树的所有节点比他的左子节点大，比他的右子节点小。）的特性的二叉树，如果将二叉搜索树按中序遍历的话，得到的就是一个有序数组了。那么反过来，我们可以得知，根节点应该是有序数组的中间点，从中间点分开为左右两个有序数组，在分别找出其中间点作为原中间点的左右两个子节点，这不就是二分查找法的核心思想么。所以这道题考的就是二分查找法。 我的解答： 12345678910111213public static TreeNode sortedArrayToBST(int[] nums) &#123; return sortedArrayToBST(nums,0,nums.length - 1);&#125;private static TreeNode sortedArrayToBST(int[] nums,int left,int right)&#123; if (left &gt; right) return null; int mid = (left + right) / 2; TreeNode node = new TreeNode(nums[mid]); node.left = sortedArrayToBST(nums,left,mid - 1); node.right = sortedArrayToBST(nums,mid+1,right); return node;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>树</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[二叉树的层次遍历]]></title>
    <url>%2F2019%2F02%2F13%2F%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E6%AC%A1%E9%81%8D%E5%8E%86%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：102 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如:给定二叉树: [3,9,20,null,null,15,7], 12345 3 / \9 20 / \ 15 7 返回其层次遍历结果： 12345[ [3], [9,20], [15,7]] 我的解答： 12345678910111213141516171819202122232425public static List&lt;List&lt;Integer&gt;&gt; levelOrder(TreeNode root) &#123; List&lt;List&lt;Integer&gt;&gt; lists = new ArrayList&lt;&gt;(); Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;(); queue.add(root); while (!queue.isEmpty())&#123; int size = queue.size(); List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); for (int i = 0;i &lt; size;i ++)&#123; TreeNode node = queue.poll(); if (node != null) &#123; list.add(node.val); queue.add(node.left); queue.add(node.right); &#125; &#125; if (list.size() != 0)&#123; lists.add(list); &#125; &#125; return lists;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>树</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[对称二叉树]]></title>
    <url>%2F2019%2F02%2F12%2F%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：101 给定一个二叉树，检查它是否是镜像对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 12345 1 / \ 2 2 / \ / \3 4 4 3 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 12345 1 / \2 2 \ \ 3 3 说明:如果你可以运用递归和迭代两种方法解决这个问题，会很加分。 题解：可以看做镜像，左边等于镜像的右边 递归： 1234567891011121314151617public static boolean isSymmetric(TreeNode root) &#123; if (root == null) return true; return comparison(root.left,root.right);&#125;private static boolean comparison(TreeNode p,TreeNode q)&#123; if (p == null &amp;&amp; q == null)&#123; return true; &#125; if (p == null || q == null)&#123; return false; &#125; if (p.val != q.val)&#123; return false; &#125; return comparison(p.left,q.right) &amp;&amp; comparison(p.right,q.left);&#125; 迭代： 123456789101112131415161718public static boolean isSymmetric(TreeNode root) &#123; if (root == null) return true; Queue&lt;TreeNode&gt; q = new LinkedList&lt;&gt;(); q.add(root.left); q.add(root.right); while (!q.isEmpty()) &#123; TreeNode t1 = q.poll(); TreeNode t2 = q.poll(); if (t1 == null &amp;&amp; t2 == null) continue; if (t1 == null || t2 == null) return false; if (t1.val != t2.val) return false; q.add(t1.left); q.add(t2.right); q.add(t1.right); q.add(t2.left); &#125; return true;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>树</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[验证二叉搜索树]]></title>
    <url>%2F2019%2F01%2F31%2F%E9%AA%8C%E8%AF%81%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：98 给定一个二叉树，判断其是否是一个有效的二叉搜索树。假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例1：12345输入: 2 / \ 1 3输出: true 示例2：123456789输入: 5 / \ 1 4 / \ 3 6输出: false解释: 输入为: [5,1,4,null,null,3,6]。 根节点的值为 5 ，但是其右子节点值为 4 。 题解：左边符合二叉搜索树但是值必须必最顶层根节点的小，右边符合二叉搜索树但是值必须必最顶层根节点的大 最优的解答：12345678910public static boolean isValidBST(TreeNode root) &#123; if (root == null) return true; return isValidBST(root,Long.MIN_VALUE,Long.MAX_VALUE);&#125;private static boolean isValidBST(TreeNode root,long min,long max)&#123; if (root == null) return true; if (root.val &gt;= max) return false; if (root.val &lt;= min) return false; return isValidBST(root.left,min,root.val) &amp;&amp; isValidBST(root.right,root.val,max);&#125; 我的解答：123456789101112131415161718//中序遍历public static boolean isValidBST(TreeNode root) &#123; if (root == null) return true; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); addToList(root, list); for (int i = 1;i &lt; list.size();i ++)&#123; if (list.get(i - 1) &gt;= list.get(i))&#123; return false; &#125; &#125; return true;&#125;private static void addToList(TreeNode root, List&lt;Integer&gt; list) &#123; if (root == null) return; addToList(root.left, list); list.add(root.val); addToList(root.right, list);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>树</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[二叉树的最大深度]]></title>
    <url>%2F2019%2F01%2F30%2F%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：104 给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]，12345 3 / \9 20 / \ 15 7 返回它的最大深度 3 。 我的解答：1234public static int maxDepth(TreeNode root) &#123; if (root == null) return 0; return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>树</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[环形链表]]></title>
    <url>%2F2019%2F01%2F29%2F%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：141 给定一个链表，判断链表中是否有环。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例1：123输入：head = [3,2,0,-4], pos = 1输出：true解释：链表中有一个环，其尾部连接到第二个节点。 示例2：123输入：head = [1,2], pos = 0输出：true解释：链表中有一个环，其尾部连接到第一个节点。 示例3：123输入：head = [1], pos = -1输出：false解释：链表中没有环。 进阶：你能用 O(1)（即，常量）内存解决此问题吗 我的解答：12345678910111213public static boolean hasCycle(ListNode head) &#123; if (head == null || head.next == null) return false; ListNode slow = head; ListNode fast = head.next; while (slow != fast) &#123; if (fast == null || fast.next == null) &#123; return false; &#125; slow = slow.next; fast = fast.next.next; &#125; return true;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[回文链表]]></title>
    <url>%2F2019%2F01%2F28%2F%E5%9B%9E%E6%96%87%E9%93%BE%E8%A1%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：234 请判断一个链表是否为回文链表。 示例21：12输入: 1-&gt;2输出: false 示例2：12输入: 1-&gt;2-&gt;2-&gt;1输出: true 进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 最优的解答： 123456789101112131415161718192021222324252627282930313233343536373839404142434445public static boolean isPalindrome(ListNode head) &#123; if (head == null || head.next == null) &#123; return true; &#125; // 找到链表的中点 ListNode mid = findMid(head); // 翻转中点后的链表 mid = reverseList(mid); // 比较两段链表 while (mid != null) &#123; if (head.val != mid.val) &#123; return false; &#125; head = head.next; mid = mid.next; &#125; return true;&#125;// 找到链表的中间节点private static ListNode findMid(ListNode head) &#123; if (head == null || head.next == null) &#123; return head; &#125; ListNode slow = head; ListNode fast = head; while(fast != null &amp;&amp; fast.next != null) &#123; slow = slow.next; fast = fast.next.next; &#125; return slow;&#125;//反转链表private static ListNode reverseList(ListNode head) &#123; if (head == null || head.next == null) &#123; return head; &#125; ListNode pre = null, now = head; while (now != null) &#123; ListNode next = now.next; now.next = pre; pre = now; now = next; &#125; return pre;&#125; 我的解答： 123456789101112131415public static boolean isPalindrome(ListNode head) &#123; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); while (head != null)&#123; list.add(head.val); head = head.next; &#125; for (int i = 0;i &lt; list.size() / 2;i ++)&#123; int num1 = list.get(i); int num2 = list.get(list.size() - 1 - i); if (num1 != num2)&#123; return false; &#125; &#125; return true;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[合并两个有序链表]]></title>
    <url>%2F2019%2F01%2F26%2F%E5%90%88%E5%B9%B6%E4%B8%A4%E4%B8%AA%E6%9C%89%E5%BA%8F%E9%93%BE%E8%A1%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：21 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例：12输入：1-&gt;2-&gt;4, 1-&gt;3-&gt;4输出：1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4 最优解答： 解题思路：将两个链表的头部进行比较，如l1.val &lt; l2.val，l1继续拿下一个与l2比较;反之亦然,直到其中一个走完全部数据,然后把另一个未走完的数据,拼接到已排序好的链表中 1234567891011121314151617181920212223public static ListNode mergeTwoLists(ListNode l1, ListNode l2) &#123; // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); ListNode cur = dummyHead; while (l1 != null &amp;&amp; l2 != null) &#123; if (l1.val &lt; l2.val) &#123; cur.next = l1; cur = cur.next; l1 = l1.next; &#125; else &#123; cur.next = l2; cur = cur.next; l2 = l2.next; &#125; &#125; // 任一为空，直接连接另一条链表 if (l1 == null) &#123; cur.next = l2; &#125; else &#123; cur.next = l1; &#125; return dummyHead.next;&#125; 我的解答： 解题思路：通过遍历两个ListNode，把值存储到List中，对List的进行排序，再对list遍历，用新的ListNode来存值 12345678910111213141516171819202122232425262728293031323334public static ListNode mergeTwoLists(ListNode l1, ListNode l2) &#123; if (l1 == null) return l2; if (l2 == null) return l1; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); list.add(l1.val); while (l1.next != null)&#123; list.add(l1.next.val); l1 = l1.next; &#125; list.add(l2.val); while (l2.next != null)&#123; list.add(l2.next.val); l2 = l2.next; &#125; Collections.sort(list, new Comparator&lt;Integer&gt;() &#123; @Override public int compare(Integer o1, Integer o2) &#123; return o1 - o2; &#125; &#125;); ListNode newNode = null; ListNode temp = null; for (int i = 0; i &lt; list.size(); i ++) &#123; if (newNode == null) &#123; newNode = new ListNode(list.get(i)); temp = newNode; &#125; else &#123; temp.next = new ListNode(list.get(i)); temp = temp.next; &#125; &#125; return newNode;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[反转链表]]></title>
    <url>%2F2019%2F01%2F25%2F%E5%8F%8D%E8%BD%AC%E9%93%BE%E8%A1%A8%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：206 反转一个单链表。 示例：12输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL输出: 5-&gt;4-&gt;3-&gt;2-&gt;1-&gt;NULL 进阶:你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ 最优的解答：12345678910111213public static ListNode reverseList(ListNode head) &#123; if(head == null || head.next == null) &#123; return head; &#125; ListNode pre = null, now = head; while (now != null) &#123; ListNode next = now.next; now.next = pre; pre = now; now = next; &#125; return pre;&#125; 我的解答：123456789101112131415161718192021public static ListNode reverseList(ListNode head) &#123; if (head == null || head.next == null) return head; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); list.add(head.val); while (head.next != null)&#123; list.add(head.next.val); head = head.next; &#125; ListNode newNode = null; ListNode temp = null; for (int i = list.size() - 1;i&gt;=0;i--)&#123; if (newNode == null)&#123; newNode = new ListNode(list.get(i)); temp = newNode; &#125;else &#123; temp.next = new ListNode(list.get(i)); temp = temp.next; &#125; &#125; return newNode;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[十大经典排序算法]]></title>
    <url>%2F2019%2F01%2F24%2F%E5%8D%81%E5%A4%A7%E7%BB%8F%E5%85%B8%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95%2F</url>
    <content type="text"><![CDATA[排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度： 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序； O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。 关于稳定性：稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。名词解释：n：数据规模k：“桶”的个数In-place：占用常数内存，不占用额外内存Out-place：占用额外内存稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同 详情转载https://github.com/hustcc/JS-Sorting-Algorithm]]></content>
      <categories>
        <category>算法</category>
      </categories>
  </entry>
  <entry>
    <title><![CDATA[删除链表的倒数第N个节点]]></title>
    <url>%2F2019%2F01%2F24%2F%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B9%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：19 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 示例：123给定一个链表: 1-&gt;2-&gt;3-&gt;4-&gt;5, 和 n = 2.当删除了倒数第二个节点后，链表变为 1-&gt;2-&gt;3-&gt;5. 说明：给定的 n 保证是有效的。 我的解答：123456789101112131415161718192021222324252627282930313233public static ListNode removeNthFromEnd(ListNode head, int n) &#123; if (n == 0) return head; int index = 1; ListNode temp = head; while (temp.next != null)&#123; index ++; temp = temp.next; &#125; if (index == 1 &amp;&amp; n == 1) return null; int i = 0; temp = head; while (temp.next != null)&#123; if (n == 1 &amp;&amp; i == index - n - 1)&#123; temp.next = null; return head; &#125; if (index == n)&#123; head.val = head.next.val; head.next = head.next.next; return head; &#125; if (i == index - n)&#123; temp.val = temp.next.val; temp.next = temp.next.next; return head; &#125; i++; temp = temp.next; &#125; return head;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[删除链表中的节点]]></title>
    <url>%2F2019%2F01%2F23%2F%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：237 请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。现有一个链表 – head = [4,5,1,9]，它可以表示为: 示例1：123输入: head = [4,5,1,9], node = 5输出: [4,1,9]解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -&gt; 1 -&gt; 9. 示例2：123输入: head = [4,5,1,9], node = 1输出: [4,5,9]解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -&gt; 5 -&gt; 9. 说明: 链表至少包含两个节点。 链表中所有节点的值都是唯一的。 给定的节点为非末尾节点并且一定是链表中的一个有效节点。 不要从你的函数中返回任何结果。 题解： 给我们的这个node就是链表的一部分，直接在上面操作就可以了，不要纠结为什么没有head 我的解答：1234public void deleteNode(ListNode node) &#123; node.val = node.next.val; node.next = node.next.next;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>链表</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[最长公共前缀]]></title>
    <url>%2F2019%2F01%2F22%2F%E6%9C%80%E9%95%BF%E5%85%AC%E5%85%B1%E5%89%8D%E7%BC%80%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：14 编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 “”。 示例1：12输入: [&quot;flower&quot;,&quot;flow&quot;,&quot;flight&quot;]输出: &quot;fl&quot; 示例2：123输入: [&quot;dog&quot;,&quot;racecar&quot;,&quot;car&quot;]输出: &quot;&quot;解释: 输入不存在公共前缀。 最优的解答：123456789101112public String longestCommonPrefix(String[] strs) &#123; if(strs.length==0) return &quot;&quot;; String repeat=strs[0]; for(int i = 1;i &lt; strs.length;i ++) &#123; //不是从第一位开始相等的,就将最后一位去掉 while(strs[i].indexOf(repeat) != 0) &#123; repeat = repeat.substring(0,repeat.length()-1); if(repeat.length()==0) return &quot;&quot;; &#125; &#125; return repeat;&#125; 我的解答：123456789101112131415161718192021222324252627public static String longestCommonPrefix(String[] strs) &#123; if (strs.length == 0) return &quot;&quot;; List&lt;String&gt; list = new ArrayList&lt;&gt;(); for (int i = 0;i &lt; strs.length;i ++)&#123; list.add(strs[i]); &#125; Collections.sort(list, new Comparator&lt;String&gt;() &#123; @Override public int compare(String o1, String o2) &#123; return o1.length() - o2.length(); &#125; &#125;); String shortStr = list.get(0); list.remove(shortStr); String str = &quot;&quot;; for (int i = 0;i &lt; shortStr.length();i ++)&#123; for (String string:list)&#123; if (shortStr.charAt(i) != string.charAt(i))&#123; return str; &#125; &#125; str += shortStr.charAt(i); &#125; return str;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[报数]]></title>
    <url>%2F2019%2F01%2F21%2F%E6%8A%A5%E6%95%B0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：38 报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：123451. 12. 113. 214. 12115. 111221 1 被读作 “one 1” (“一个一”) , 即 11。11 被读作 “two 1s” (“两个一”）, 即 21。21 被读作 “one 2”, “one 1” （”一个二” , “一个一”) , 即 1211。 给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。注意：整数顺序将表示为一个字符串。 示例1：12输入: 1输出: &quot;1&quot; 示例2：12输入: 4输出: &quot;1211&quot; 我的解答：123456789101112131415161718192021222324252627public static String countAndSay(int n) &#123; if (n == 1) return &quot;1&quot;; if (n == 2) return &quot;11&quot;; String str = &quot;11&quot;; StringBuilder builder = new StringBuilder(); for (int i = 2;i &lt; n;i ++)&#123; char c = str.charAt(0); int index = 1; for (int j = 1;j &lt; str.length();j ++)&#123; if (str.charAt(j) == c)&#123; index ++; &#125;else &#123; builder.append(index); builder.append(c); c = str.charAt(j); index = 1; &#125; if (j == str.length() - 1)&#123; builder.append(index); builder.append(c); &#125; &#125; str = builder.toString(); builder.setLength(0); &#125; return str;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[实现strStr()]]></title>
    <url>%2F2019%2F01%2F19%2F%E5%AE%9E%E7%8E%B0strStr()%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：28 实现 strStr() 函数。给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。 示例1：12输入: haystack = &quot;hello&quot;, needle = &quot;ll&quot;输出: 2 示例2：12输入: haystack = &quot;aaaaa&quot;, needle = &quot;bba&quot;输出: -1 说明:当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr()以及 Java的 indexOf()定义相符。 java indexOf()的代码:12345678910111213141516171819202122232425public static int strStr(String haystack, String needle) &#123; if (needle.length() == 0) return 0; final int sourceLength = haystack.length(); final int targetLength = needle.length(); char first = needle.charAt(0); int max = (sourceLength - targetLength); for (int i = 0; i &lt;= max; i++) &#123; if (haystack.charAt(i)!= first) &#123; while (++i &lt;= max &amp;&amp; haystack.charAt(i) != first); &#125; if (i &lt;= max) &#123; int j = i + 1; int end = j + targetLength - 1; for (int k = 1; j &lt; end &amp;&amp; haystack.charAt(j) == needle.charAt(k); j++, k++); if (j == end) &#123; return i; &#125; &#125; &#125; return -1;&#125; 我的解答：1234567891011121314151617181920public static int strStr(String haystack, String needle) &#123; if (needle.length() == 0) return 0; if (needle.length() &gt; haystack.length()) return -1; for (int i = 0;i &lt; haystack.length();i ++)&#123; if (haystack.charAt(i) == needle.charAt(0))&#123; int j = i + 1; int end = j + needle.length() - 1; for (int k = 1;k &lt; needle.length() &amp;&amp; j &lt; haystack.length();j++,k ++)&#123; if (haystack.charAt(j) != needle.charAt(k))&#123; break; &#125; &#125; if (j == end) return i; &#125; &#125; return -1;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[字符串转换整数 (atoi)]]></title>
    <url>%2F2019%2F01%2F18%2F%E5%AD%97%E7%AC%A6%E4%B8%B2%E8%BD%AC%E6%8D%A2%E6%95%B4%E6%95%B0%20(atoi)%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：8 请你来实现一个 atoi 函数，使其能将字符串转换成整数。首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。在任何情况下，若函数不能进行有效的转换时，请返回 0。 说明：假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，qing返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。 示例1：12输入: &quot;42&quot;输出: 42 示例2：1234输入: &quot; -42&quot;输出: -42解释: 第一个非空白字符为 &apos;-&apos;, 它是一个负号。 我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。 示例3：123输入: &quot;4193 with words&quot;输出: 4193解释: 转换截止于数字 &apos;3&apos; ，因为它的下一个字符不为数字。 示例4：1234输入: &quot;words and 987&quot;输出: 0解释: 第一个非空字符是 &apos;w&apos;, 但它不是数字或正、负号。 因此无法执行有效的转换。 示例5：1234输入: &quot;-91283472332&quot;输出: -2147483648解释: 数字 &quot;-91283472332&quot; 超过 32 位有符号整数范围。 因此返回 INT_MIN (−231) 。 我的解答：12345678910111213141516171819202122232425262728293031323334353637public static int myAtoi(String str) &#123; str = str.trim(); if (str.length() == 0) return 0; if (str.equals(&quot;+&quot;) || str.equals(&quot;-&quot;))return 0; String string = &quot;&quot;+str.charAt(0); if ((!(string.equals(&quot;+&quot;) || string.equals(&quot;-&quot;) || isNumber(str.charAt(0)))))&#123; return 0; &#125; StringBuilder builder = new StringBuilder(); builder.append(string); for (int i = 1;i &lt; str.length();i ++)&#123; char c = str.charAt(i); if (isNumber(c))&#123; builder.append(c); &#125;else &#123; break; &#125; &#125; if (builder.toString().equals(&quot;+&quot;) || builder.toString().equals( &quot;-&quot;)) return 0; Double num = Double.parseDouble(builder.toString()); if (num&gt;Integer.MAX_VALUE) return Integer.MAX_VALUE; if (num&lt;Integer.MIN_VALUE) return Integer.MIN_VALUE; return num.intValue();&#125;private static boolean isNumber(char c) &#123; String number = &quot;0123456789&quot;; if (number.indexOf(c) == -1)&#123; return false; &#125; return true;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>中等</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[验证回文串]]></title>
    <url>%2F2019%2F01%2F17%2F%E9%AA%8C%E8%AF%81%E5%9B%9E%E6%96%87%E4%B8%B2%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：125 给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 说明：本题中，我们将空字符串定义为有效的回文串。 示例1：12输入: &quot;A man, a plan, a canal: Panama&quot;输出: true 示例2：12输入: &quot;race a car&quot;输出: false 我的解答：123456789101112public static boolean isPalindrome(String s) &#123; //可以替换大部分空白字符， 不限于空格 . 说明:\s 可以匹配空格、制表符、换页符等 空白字符的其中任意一个 s = s.trim().replaceAll(&quot;\\s*&quot;,&quot;&quot;); //清除所有符号,只留下字母 数字 汉字 共3类. s = s.replaceAll(&quot;[\\p&#123;P&#125;\\p&#123;Punct&#125;]&quot;,&quot;&quot;).toLowerCase(); for (int i = 0;i &lt; s.length()/2;i ++)&#123; if (s.charAt(i) != s.charAt(s.length() - 1 - i))&#123; return false; &#125; &#125; return true;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[有效的字母异位词]]></title>
    <url>%2F2019%2F01%2F16%2F%E6%9C%89%E6%95%88%E7%9A%84%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8D%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：242 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。 示例1：12输入: s = &quot;anagram&quot;, t = &quot;nagaram&quot;输出: true 示例2：12输入: s = &quot;rat&quot;, t = &quot;car&quot;输出: false 说明:你可以假设字符串只包含小写字母。 进阶:如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？ 我的解答：123456789101112public boolean isAnagram(String s, String t) &#123; if (s.length() != t.length()) return false; char[] chars1 = s.toCharArray(); Arrays.sort(chars1); char[] chars2 = t.toCharArray(); Arrays.sort(chars2); if (!String.valueOf(chars1).equals(String.valueOf(chars2)))&#123; return false; &#125; return true;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[IPC机制]]></title>
    <url>%2F2019%2F01%2F16%2FIPC%E6%9C%BA%E5%88%B6%2F</url>
    <content type="text"><![CDATA[本文内容来自《Android开发艺术探索》 IPC是Inter-Process-Communication的缩写，意思是进程间通信或者跨进程通信；说起进程间通信，我们应该首先来了解一下什么是进程。按照操作系统的描述，线程是CPU调度的最小单元，而进程一般指一个执行单元，在移动设备上指一个程序或应用；一个进程可以包含多个线程。 Android 开启多进程模式在AndroidMenifest中为。四大组件指定 android:proccess 属性，这是唯一一种常规开启多进程的方法。如下图所示:12345678//用 : 命名，当前完整进程名要加上包名，表示当前应用的私有进程&lt;activity android:name=&quot;.TestActivityOne&quot; android:process=&quot;:test1&quot;/&gt;//不以 : 为命名的进程属于全局进程，其他应用可以通过ShareUID方式和它跑在同一进程 &lt;activity android:name=&quot;.TestActivityTwo&quot; android:process=&quot;com.test.test2&quot;/&gt; 还有一种非常规的方法，就是通过JNI在native层去fork一个新进程 多进程会造成几个方面的问题： 静态成员和单例模式完全失效(不在同一内存) 线程同步机制完成失效(与1类似) SharePreferences的可靠性下降(底层是通过读/写XML来实现的) Application会多次创建 Serializable和Parcelable的区别Serializable是Java中的序列化接口,其使用起来简单但是开销很大，序列化和反序列化过程需要大量的I/O操作。而Parcelable是Android中的序列化方式，更适合Android平台，缺点是使用起来麻烦，但是效率很高，主要用在内存序列化上。 Binder直观来说，Binder是Android中的一个类，它实现了IBinder接口。从IPC角度来说，Binder是Android中的一种跨进程通信方式，Binder还可以理解为一种虚拟的物理设备，它的设备驱动是dev/binder,该通信方式在Linux中没有；从AndroidFramework角度来说，Binder是ServiceManager连接各种Manager(ActivityManager、WindowManager,等等）和相应ManagerService的桥梁；从Android应用层来说，Binder是客户端和服务端进行通信的媒介，当bindService的时候，服务端会返回一个包含了服务端业务调用的Binder对象，通过这个Binder对象，客户端就可以获取服务端提供的服务或者数据，这里的服务包括普通服务和基于AIDL的服务。 Android中的IPC方式 Bundle 文件共享 Messenger AIDL ContentProvider Scoket Bundle适用于在三大组件(Activity、Service、Receiver)里通过Bundle来传输数据，可以在不同进程中。 文件共享文件共享适合在对数据同步要求不高的进程中进行通信，并且要妥善处理并发读/写的问题 Messenger底层实现是AIDL。一次只处理一个请求，所以可以不必考虑线程同步的问题(因为服务端不存在并发操作) Messenger的工作原理如下： AIDL从系统自动帮我们把aidl文件生成java文件来看，核心实现是生成的内部类Sub和Sub的内部代理类Proxy。当客户端和服务端都位于同一进程时，方法调用不会走快进程的transact过程，而当两者位于不同进程时，方法调用需要走transact过程，这个逻辑由Sub的内部代理类Proxy来完成。 注意点:1.首先，当客户端发起远程诮求时，由于当前线程会被挂起直至服务端进程返回数据，所以如果一个远程方法是很耗时的，那么不能在UI线程中发起此远程请求；其次，由于服务端的Binder方法运行在Binder的线程池中，所以Binder方法不管是否耗时都应该采用同步的方式去实现，因为它已经运行在一个线程中了2.如果AIDL文件中用到了自定义的Parcelable对象，那么必须新建一个和它同名的AIDL文件，并在其中声明为Parcelable类型，如下所示：java文件：AIDL文件：3.AIDL中除了基本数据类型，其他类型的参数必须标上方向：in、out或者inout，in表示输入型参数，out表示输出型参数 4.对象是不能跨进程直接传输，对象的跨进程传输本质上都是反序列化的过程 5.防止Binder意外死亡，有两种处理方法。一种是给Binder设置DeathRecipient监听，当Binder死亡时,会在binderDied()方法里收到回调。还有一种就是在onServiceDisconnected 中重新连接远程服务。区别在于onServiceDisconnected 在客户端的UI线程中被回调，而binderDied在客户端的Binder线程池中被回调。也就是，在binderDied中不能访问UI。 6.权限认证。可以在Service中的onBind里进行验证(比如加permission验证)，也可以在具体AIDL的java类中的onTransact中进行权限认证；还可以采用Uid和Pid来做验证 ContentProvider为存储和获取数据提供统一的接口。可以在不同的应用程序之间共享数据。可支持在多个应用中存储和读取数据。底层实现也是Binder。操作流程图： 注意点：1.query、update、insert、delete四个方法是存在多线程并发访问的，因此调用方法内部要做好线程同步 ScocketSocket也称为“套接字“，是网络通信中的概念，它分为流式套接字和用户数据报套接字两种，分别对应于网络的传输控制层中的TCP和UDP协议。TCP协议是面向连接的协议，提供稳定的双向通信功能，TCP连接的建立需要经过“三次握手”才能完成，为了提供稳定的数据传输功能，其本身提供了超时重传机制，因此具有很高的稳定性：而UDP是无连接的，提供不稳定的单向通信功能，当然UDP也可以实现双向通信功能，在性能上，UDP具有更好的效率，其缺点是不保证数据一定能够正确传输，尤其是在网络拥塞的情况下。 注意点：1.需要在AndroidManifest.xml中声明权限123&lt;uses-permission android:name=&quot;android.permission.INTERNET&quot; /&gt;&lt;uses-permission android:name=&quot;android.permission.ACCESS_NETWORK_STATE&quot; /&gt; Binder连接池随着项目越来越大，业务模块不断增多，不同模块需要对应AIDL接口，之前的是一个业务对应一个Service。但是业务模块庞大，不适合这种单一对应，会造成系统资源不断消耗，所以要采用新的工作机制。整个工作机制是这样的：每个业务模块创建自己的AIDL接口并实现此接口，这个时候不同业务模块之间是不能有耦合的，所有实现细节我们要单独开来，然后向服务端提供自己的唯一标识和其对应的Binder对象；对于服务端来说，只要一个Service就可以了，服务端提供一个queryBinder接口，这个接口能够根据业务模块的特征来返回相应的Binder对象给它们，不间的业务模块拿到所需的Binder对象后就可以进行远程方法调用了。由此可见，Binder连接池的主要作用就是将每个业务模块的Binder请求统一转发到远程Service中去执行，从而避免了重复创建Service的过程。 选用合适的IPC方式 名称 优点 缺点 适用场景 Bundle 简单易用 只能传输Bundle支持的数据类型 四大组件间的进程通信 文件共享 简单易用 不适合高并发的情况，并且无法做到进程间的即时通讯 无并发访问情况下，交换简单的数据实时性不高的情况 AIDL 功能强大,支持一对多并发通信，支持实时通讯 需要处理好线程同步 一对多通信且有Rpc需求 Messenger 功能一般，支持一对多串行通信，支持实时通讯 不能很好处理高并发情况，不支持Rpc，数据通过Message进行传输，因此只能传输Bundle支持的数据类型 低并发的一对多即时通信,无Rpc需求，或者无需返回结果的Rpc需求 ContentProvider 在数据源访问方面功能强大,支持一对多并发数据共享，可通过Call方法扩展其他操作(call在源码编译下可调用 主要提供数据源的Crud 一对多的进程间数据共享 Socket 功能强大,可以通过网络传输字节流，支持一对多并发实时通讯 实现细节有点繁琐，不支持直接的Rpc(调用远程服务的方法) 网络数据交换]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>TCP</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[字符串中的第一个唯一字符]]></title>
    <url>%2F2019%2F01%2F15%2F%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E7%9A%84%E7%AC%AC%E4%B8%80%E4%B8%AA%E5%94%AF%E4%B8%80%E5%AD%97%E7%AC%A6%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：387 给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。 示例：12345s = &quot;leetcode&quot;返回 0.s = &quot;loveleetcode&quot;,返回 2. 注意事项：您可以假定该字符串只包含小写字母。 我的解答：123456789public int firstUniqChar(String s) &#123; for (int i=0;i&lt;s.length();i++)&#123; int index = s.indexOf(s.charAt(i)); if (s.lastIndexOf(s.charAt(i)) == index)&#123; return i; &#125; &#125; return -1;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[整数反转]]></title>
    <url>%2F2019%2F01%2F14%2F%E6%95%B4%E6%95%B0%E5%8F%8D%E8%BD%AC%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：7 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。 示例1：12输入: 123输出: 321 示例2：12输入: -123输出: -321 示例3：12输入: 120输出: 21 注意:假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。 最优解答：12345678910public int reverse(int x) &#123; int result = 0; while(x != 0)&#123; if(result &gt; Integer.MAX_VALUE / 10 || result &lt; Integer.MIN_VALUE / 10) return 0; result = result * 10 + x % 10; x /= 10; &#125; return result;&#125; 我的解答：12345678910111213141516171819202122232425public int reverse(int x) &#123; try &#123; if (x &gt;= 0)&#123; x = Integer.parseInt(reverseString(&quot;&quot;+x)); &#125;else &#123; x = 0 - Integer.parseInt(reverseString(&quot;&quot;+Math.abs(x))); &#125; &#125;catch (NumberFormatException e)&#123; return 0; &#125; return x;&#125;public String reverseString(String s) &#123; char[] chars = s.toCharArray(); for (int i = 0;i &lt; chars.length/2;i ++)&#123; char tmp = chars[i]; chars[i] = chars[chars.length - 1 - i]; chars[chars.length - 1 - i] = tmp; &#125; return new String(chars);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[有效的数独]]></title>
    <url>%2F2019%2F01%2F12%2F%E6%9C%89%E6%95%88%E7%9A%84%E6%95%B0%E7%8B%AC%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：36 判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 上图是一个部分填充的有效的数独。数独部分空格内已填入了数字，空白格用 ‘.’ 表示。 示例1：12345678910111213输入:[ [&quot;5&quot;,&quot;3&quot;,&quot;.&quot;,&quot;.&quot;,&quot;7&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;], [&quot;6&quot;,&quot;.&quot;,&quot;.&quot;,&quot;1&quot;,&quot;9&quot;,&quot;5&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;], [&quot;.&quot;,&quot;9&quot;,&quot;8&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;6&quot;,&quot;.&quot;], [&quot;8&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;6&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;3&quot;], [&quot;4&quot;,&quot;.&quot;,&quot;.&quot;,&quot;8&quot;,&quot;.&quot;,&quot;3&quot;,&quot;.&quot;,&quot;.&quot;,&quot;1&quot;], [&quot;7&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;2&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;6&quot;], [&quot;.&quot;,&quot;6&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;2&quot;,&quot;8&quot;,&quot;.&quot;], [&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;4&quot;,&quot;1&quot;,&quot;9&quot;,&quot;.&quot;,&quot;.&quot;,&quot;5&quot;], [&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;8&quot;,&quot;.&quot;,&quot;.&quot;,&quot;7&quot;,&quot;9&quot;]]输出: true 示例2：123456789101112131415输入:[ [&quot;8&quot;,&quot;3&quot;,&quot;.&quot;,&quot;.&quot;,&quot;7&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;], [&quot;6&quot;,&quot;.&quot;,&quot;.&quot;,&quot;1&quot;,&quot;9&quot;,&quot;5&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;], [&quot;.&quot;,&quot;9&quot;,&quot;8&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;6&quot;,&quot;.&quot;], [&quot;8&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;6&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;3&quot;], [&quot;4&quot;,&quot;.&quot;,&quot;.&quot;,&quot;8&quot;,&quot;.&quot;,&quot;3&quot;,&quot;.&quot;,&quot;.&quot;,&quot;1&quot;], [&quot;7&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;2&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;6&quot;], [&quot;.&quot;,&quot;6&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;2&quot;,&quot;8&quot;,&quot;.&quot;], [&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;4&quot;,&quot;1&quot;,&quot;9&quot;,&quot;.&quot;,&quot;.&quot;,&quot;5&quot;], [&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;8&quot;,&quot;.&quot;,&quot;.&quot;,&quot;7&quot;,&quot;9&quot;]]输出: false解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。 说明: 一个有效的数独（部分已被填充）不一定是可解的。 只需要根据以上规则，验证已经填入的数字是否有效即可。 给定数独序列只包含数字 1-9 和字符 ‘.’ 。 给定数独永远是 9x9 形式的。 我的解答：123456789101112131415161718192021222324252627282930313233343536public boolean isValidSudoku(char[][] board) &#123; Map&lt;Integer,Map&lt;Character,Character&gt;&gt; rowMap = new HashMap&lt;&gt;(); Map&lt;Integer,Map&lt;Character,Character&gt;&gt; colMap = new HashMap&lt;&gt;(); Map&lt;Integer,Map&lt;Character,Character&gt;&gt; blockMap = new HashMap&lt;&gt;(); for (int i = 0;i &lt; 9;i ++)&#123; for (int j = 0;j &lt; 9;j ++)&#123; if (board[i][j] != &apos;.&apos;)&#123; char num = board[i][j]; if ((rowMap.get(i) != null &amp;&amp; rowMap.get(i).containsKey(num)) || (colMap.get(j) != null &amp;&amp; colMap.get(j).containsKey(num)) || (blockMap.get(i / 3 * 3 + j / 3) != null &amp;&amp; blockMap.get(i / 3 * 3 + j / 3） .containsKey(num)))&#123; return false; &#125;else &#123; addValue(rowMap,i,num); addValue(colMap,j,num); addValue(blockMap,i / 3 * 3 + j / 3,num); &#125; &#125; &#125; &#125; return true;&#125;private void addValue(Map&lt;Integer,Map&lt;Character,Character&gt;&gt; map,int index,char num)&#123; if (map.get(index) == null)&#123; Map&lt;Character,Character&gt; newMap = new HashMap&lt;&gt;(); newMap.put(num,num); map.put(index,newMap); &#125;else &#123; map.get(index).put(num,num); &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数组</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Activity的生命周期和启动模式]]></title>
    <url>%2F2019%2F01%2F11%2FActivity%E7%9A%84%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F%E5%92%8C%E5%90%AF%E5%8A%A8%E6%A8%A1%E5%BC%8F%2F</url>
    <content type="text"><![CDATA[本文内容来自《Android开发艺术探索》 Activity的生命周期，如图: onStart(),onResume(),onPause(),onStop()这四个状态都表示可见状态，区分他们区别是:onStart(),onStop()表示可见，但是他们不在前台；onResume(),onPause()表示可见，且位于前台； 注意点：不要在onPause()进行重量级操作,因为当前Activity的onPause()执行完成后,新的Activity才能onResume() Activity异常情况分析 Activity异常销毁并重建，生命周期如图： 异常终止会调用onSaveInstanceState来保存Activity的状态,这个方法的调用时机在onStop之前,它和onPause没有既定的时序关系，它既可能在onPause之前调用，也可能在onPause之后调用。在Activity重建之后，系统会调用onRestoreInstanceState，并且把Activity销毁时onSaveInstanceState保存的Bundle对象作为参数同时传递给onRestoreInstanceState和onCreate，我们可以通过Bundle是否为null，来判断Activity是否被重建，而且我们可以在重建后，取出保存的数据，来恢复Activity。 注意：onRestoreInstanceState一旦被调用，Bundle一定是有值的，onCreate的值要判空 从生命周期调用时序来看，onRestoreInstanceState的调用时间在onStart之后。和Activity一样，每个View也有 onSaveInstanceState 和 onRestoreInstanceState方法。在Activity在意外退出过程，系统会默认保存当前Activity的视图结构。在重建过程，系统会恢复这些保存的数据。 关于保存和恢复 View 层次结构，系统的工作流程是这样的：首先 Activity 被意外终止时， Activity 会调用 onSavelnstanceState 去保存数据， 然后 Activity 会委托 Window 去保存数据， 接着 Window 再委托它上面的顶级容器去保存数据。 顶层容器是一个 ViewGroup, 一般来说它很可能是 DecorView。最后顶层容器再去一一通知它的子元素来保存数据， 这样整个数据保存过程就完成了。可以发现这是一种典型的委托思想，上层委托下层、父层容器委托子元素去处理一件事件。 启动模式(launchMode) standard:默认模式 singleTop:栈顶复用特性，调用onNewIntent singleTask:具有栈内复用，cleanTop的属性 singleInstance:singleTask的特性全都有，而且只能单独位于一个任务栈中 taskAffinity的属性可以为Activity指定任务栈，这个属性值必须不能喝包名相同，采用和包名相同命名规范。主要和singleTask启动模式或者allowTaskReparenting属性配对使用 Activity的FlagsFLAG_ACTIVITY_NEW_TASK：指定为singleTask模式，但是不具备cleanTop，要配合FLAG_ACTIVITY_CLEAR_TOP使用 FLAG_ACTIVITY_SINGLE_TOP：指定为singleTop模式 FLAG_ACTIVITY_CLEAR_TOP：配合FLAG_ACTIVITY_NEW_TASK使用 FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS：具有这个标记的Activity不会出现在历史Activity列表中 IntentFilter的匹配规则 action：值是字符串，区分大小写，一个过滤规则可以有多个action category：Intent中如果含有category，不管有多少个，都必须和过滤规则中的其中有定义的category相同。当然，Intent中可以没有category，如果没有category的话，按照上面的描述，这个Intent仍然可以匹配成功。原因是系统在调用startActivity或者startActivityForResult的时候会默认为Intent加上”android.intent.category.DEFAULT”这个category，所以这个category就可以匹配前面的过滤规则中的第三个category。同时，为了我们的activity能够接收隐式调用，就必须在intent-filter中指定”android.intent.category.DEFAULT”这个category。即是说，在Intent中可以没有category，但有的情况下，哪怕是其中一个都不能无中生有 data：data的匹配规则和action类似，如果过滤规则中定义了data，那么Intent中必须也要定义可匹配的data data语法：1234567&lt;data android:scheme=&quot;string&quot; android:host=&quot;string&quot; android:port=&quot;string&quot; android:path=&quot;string&quot; android:pathPattern=&quot;string&quot; android:pathPrefix=&quot;string&quot; android:mimeType=&quot;string&quot;/&gt; data由两部分组成，mimeType和URI。mimeType指媒体类型，比如image/jpeg、audio/mpeg4-generic和video/*等，可以表示图片、文本、视频等不同的媒体格式，而URI中包含的数据就比较多了，下面是URI的结构：1&lt;scheme&gt;://&lt;host&gt;:&lt;port&gt;/[&lt;path&gt;|&lt;pathPrefix&gt;|&lt;pathPattern&gt;]]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>Activity</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Android系统启动流程]]></title>
    <url>%2F2019%2F01%2F11%2FAndroid%E7%B3%BB%E7%BB%9F%E5%90%AF%E5%8A%A8%E6%B5%81%E7%A8%8B%2F</url>
    <content type="text"><![CDATA[init进程启动过程init进程是Android系统中用户空间的第一个进程，作为第一个进程，它被赋予了很多极其重要的工作职责，比如创建zygote(孵化器)和属性服务等。init进程是由多个源文件共同组成的，这些文件位于源码目录system/core/init。 说到init进程，首先要提到Android系统启动流程的前几步：1.启动电源以及系统启动当电源按下时引导芯片代码开始从预定义的地方（固化在ROM）开始执行。加载引导程序Bootloader到RAM，然后执行。2.引导程序Bootloader引导程序是在Android操作系统开始运行前的一个小程序，它的主要作用是把系统OS拉起来并运行。3.linux内核启动内核启动时，设置缓存、被保护存储器、计划列表，加载驱动。当内核完成系统设置，它首先在系统文件中寻找”init”文件，然后启动root进程或者系统的第一个进程。4.init进程启动 在初始化时，做了大量的准备工作，差不多先初始化好启动一些Service的必要参数，创建好Service对象后，再启动zygote进程 总结起来init进程主要做了三件事：1.创建一些文件夹并挂载设备2.初始化和启动属性服务3.解析init.rc配置文件并启动zygote进程 Zygote在Android系统中，DVM(Dalvik虚拟机)、应用程序进程以及运行系统的关键服务的SystemServer进程都是由Zygote进程来创建的，我们也将它称为孵化器。它通过fock(复制进程)的形式来创建应用程序进程和SystemServer进程，由于Zygote进程在启动时会创建DVM，因此通过fock而创建的应用程序进程和SystemServer进程可以在内部获取一个DVM的实例拷贝。 这个AppRuntime的main函数中，通过JNI调用ZygoteInit的main函数后，Zygote便进入Java架构层，也就是这时候创建了Java架构层 Zygote进程共做了如下几件事：1.创建AppRuntime并调用其start方法，启动Zygote进程。2.创建DVM并为DVM注册JNI.3.通过JNI调用ZygoteInit的main函数进入Zygote的Java框架层。4.通过registerZygoteSocket函数创建服务端Socket，并通过runSelectLoop函数等待ActivityManagerService的请求来创建新的应用程序进程。5.启动SystemServer进程。 SystemServerSyetemServer进程是复制了Zygote的地址空间。通过JNI调用Native层代码，启动Binder线程池，这样SyetemServer进程就可以使用Binder来与其他线程进行通信了。然后启动SystemServiceManager，启动各种其他Service SyetemServer在启动时做了如下工作：1.启动Binder线程池，这样就可以与其他进程进行通信。2.创建SystemServiceManager用于对系统的服务进行创建、启动和生命周期管理。3.启动各种系统服务(如AMS，PMS等)。 LauncherAndroid系统启动的最后一步是启动一个Home应用程序，这个应用程序用来显示系统中已经安装的应用程序，这个Home应用程序就叫做Launcher。应用程序Launcher在启动过程中会请求PackageManagerService返回系统中已经安装的应用程序的信息，并将这些信息封装成一个快捷图标列表显示在系统屏幕上，这样用户可以通过点击这些快捷图标来启动相应的应用程序。 SyetemServer进程在启动的过程中会启动PackageManagerService，PackageManagerService启动后会将系统中的应用程序安装完成。在此前已经启动的ActivityManagerService会将Launcher启动起来。 总体启动流程1.启动电源以及系统启动当电源按下时引导芯片代码开始从预定义的地方（固化在ROM）开始执行。加载引导程序Bootloader到RAM，然后执行。2.引导程序BootLoader引导程序BootLoader是在Android操作系统开始运行前的一个小程序，它的主要作用是把系统OS拉起来并运行。3.Linux内核启动内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。当内核完成系统设置，它首先在系统文件中寻找init.rc文件，并启动init进程。4.init进程启动初始化和启动属性服务，并且启动Zygote进程。5.Zygote进程启动创建JavaVM并为JavaVM注册JNI，创建服务端Socket，启动SystemServer进程。6.SystemServer进程启动启动Binder线程池和SystemServiceManager，并且启动各种系统服务。7.Launcher启动被SystemServer进程启动的ActivityManagerService会启动Launcher，Launcher启动后会将已安装应用的快捷图标显示到界面上。 ##]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>Framework</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[反转字符串]]></title>
    <url>%2F2019%2F01%2F11%2F%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：344 编写一个函数，其作用是将输入的字符串反转过来。 示例1：12输入: &quot;hello&quot;输出: &quot;olleh&quot; 示例2：12输入: &quot;A man, a plan, a canal: Panama&quot;输出: &quot;amanaP :lanac a ,nalp a ,nam A&quot; 我的解答：12345678910public String reverseString(String s) &#123; char[] chars = s.toCharArray(); for (int i = 0;i &lt; chars.length/2;i ++)&#123; char tmp = chars[i]; chars[i] = chars[chars.length - 1 - i]; chars[chars.length - 1 - i] = tmp; &#125; return new String(chars);&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>字符串</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[旋转图像]]></title>
    <url>%2F2019%2F01%2F10%2F%E6%97%8B%E8%BD%AC%E5%9B%BE%E5%83%8F%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：48 给定一个 n × n 的二维矩阵表示一个图像。将图像顺时针旋转 90 度。 说明：你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。 示例1：12345678910111213给定 matrix = [ [1,2,3], [4,5,6], [7,8,9]],原地旋转输入矩阵，使其变为:[ [7,4,1], [8,5,2], [9,6,3]] 示例2：123456789101112131415给定 matrix =[ [ 5, 1, 9,11], [ 2, 4, 8,10], [13, 3, 6, 7], [15,14,12,16]], 原地旋转输入矩阵，使其变为:[ [15,13, 2, 5], [14, 3, 4, 1], [12, 6, 8, 9], [16, 7,10,11]] 我的解答12345678910111213141516171819public static void rotate(int[][] matrix) &#123; Map&lt;Integer,Map&lt;Integer,Integer&gt;&gt; map = new HashMap&lt;&gt;(); for(int i = 0;i &lt; matrix.length;i ++)&#123; for (int j = 0;j &lt; matrix[i].length;j ++)&#123; if (map.get(i) == null)&#123; Map&lt;Integer,Integer&gt; newMap = new HashMap&lt;&gt;(); newMap.put(j,matrix[i][j]); map.put(i,newMap); &#125;else &#123; map.get(i).put(j,matrix[i][j]); &#125; &#125; &#125; for(int i = 0;i &lt; matrix.length;i ++)&#123; for (int j = 0;j &lt; matrix[i].length;j ++)&#123; matrix[j][matrix.length - 1 - i] = map.get(i).get(j); &#125; &#125;&#125; 其他解答：12345678910111213public static void rotate(int[][] matrix) &#123; for(int i = 0;i &lt; matrix.length / 2;i ++)&#123; int start = i; int end = matrix.length - 1 - i; for (int j = 0;j &lt; end - start;j ++)&#123; int temp = matrix[start][start + j]; matrix[start][start + j] = matrix[end - j][start]; matrix[end - j][start] = matrix[end][end - j]; matrix[end][end - j] = matrix[start + j][end]; matrix[start + j][end] = temp; &#125; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>数组</tag>
        <tag>中等</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[两数之和]]></title>
    <url>%2F2019%2F01%2F10%2F%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8C%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：1 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例：1234给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1] 我的解答：12345678910Map&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;();for (int i = 0;i &lt; nums.length;i ++)&#123; int value = target - nums[i]; if (map.containsKey(value))&#123; return new int[]&#123;map.get(value),i&#125;; &#125; map.put(nums[i],i);&#125;return null;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Android系统架构]]></title>
    <url>%2F2019%2F01%2F10%2FAndroid%E7%B3%BB%E7%BB%9F%E6%9E%B6%E6%9E%84%2F</url>
    <content type="text"><![CDATA[内容参考CSDN刘望舒系统架构 Android系统架构分为五层，从上到下依次是应用层、应用框架层、系统运行库层、硬件抽象层和Linux内核层。 应用层系统内置的应用程序以及非系统级的应用程序都是属于应用层。负责与用户进行直接交互，通常都是用Java进行开发的。 应用框架层(Framework层)应用框架层为开发人员提供了可以开发应用程序所需要的API，我们平常开发应用程序都是调用的这一层所提供的API，当然也包括系统的应用。这一层的是由Java代码编写的，可以称为Java Framework。下面来看这一层所提供的主要的组件。 名称 功能描述 Activity Manager(活动管理器) 管理各个应用程序生命周期以及通常的导航回退功能 Location Manager(位置管理器) 提供地理位置以及定位功能服务 Package Manager(包管理器) 管理所有安装在Android系统中的应用程序 Notification Manager(通知管理器) 使得应用程序可以在状态栏中显示自定义的提示信息 Resource Manager（资源管理器） 提供应用程序使用的各种非代码资源，如本地化字符串、图片、布局文件、颜色文件等 Telephony Manager(电话管理器) 管理所有的移动设备功能 Window Manager（窗口管理器） 管理所有开启的窗口程序 Content Providers（内容提供器） 使得不同应用程序之间可以共享数据 View System（视图系统） 构建应用程序的基本组件 系统运行库层（Native层)系统运行库层分为两部分，分别是C/C++程序库和Android运行时库。下面分别来介绍它们。 1.C/C++程序库C/C++程序库能被Android系统中的不同组件所使用，并通过应用程序框架为开发者提供服务，主要的C/C++程序库如下表所示| 名称 | 功能描述 ||:—-:|:—-:|| OpenGL ES | 3D绘图函数库 || Libc | 从BSD继承来的标准C系统函数库，专门为基于嵌入式Linux的设备定制 || Media Framework | 多媒体库，支持多种常用的音频、视频格式录制和回放。 || SQLite | 轻型的关系型数据库引擎 || SGL | 底层的2D图形渲染引擎 || SSL | 安全套接层，是为网络通信提供安全及数据完整性的一种安全协议 || FreeType | 可移植的字体引擎，它提供统一的接口来访问多种字体格式文件 | 2.Android运行时**库**运行时库又分为核心库和ART(5.0系统之后，Dalvik虚拟机被ART取代)。核心库提供了Java语言核心库的大多数功能，这样开发者可以使用Java语言来编写Android应用。相较于JVM，Dalvik虚拟机是专门为移动设备定制的，允许在有限的内存中同时运行多个虚拟机的实例，并且每一个Dalvik 应用作为一个独立的Linux 进程执行。独立的进程可以防止在虚拟机崩溃的时候所有程序都被关闭。而替代Dalvik虚拟机的ART 的机制与Dalvik 不同。在Dalvik下，应用每次运行的时候，字节码都需要通过即时编译器转换为机器码，这会拖慢应用的运行效率，而在ART 环境中，应用在第一次安装的时候，字节码就会预先编译成机器码，使其成为真正的本地应用。 硬件抽象层（HAL)硬件抽象层是位于操作系统内核与硬件电路之间的接口层，其目的在于将硬件抽象化，为了保护硬件厂商的知识产权，它隐藏了特定平台的硬件接口细节，为操作系统提供虚拟硬件平台，使其具有硬件无关性，可在多种平台上进行移植。 从软硬件测试的角度来看，软硬件的测试工作都可分别基于硬件抽象层来完成，使得软硬件测试工作的并行进行成为可能。通俗来讲，就是将控制硬件的动作放在硬件抽象层中。 Linux层Android 的核心系统服务基于Linux 内核，在此基础上添加了部分Android专用的驱动。系统的安全性、内存管理、进程管理、网络协议栈和驱动模型等都依赖于该内核。Android系统的五层架构就讲到这，了解以上的知识对以后分析系统源码有很大的帮助。 Android系统源码目录整体结构 Android源码根目录 描述 abi 应用程序二进制接口 art 全新的ART运行环境 bionic 系统C库 bootable 启动引导相关代码 build 存放系统编译规则及generic等基础开发包配置 cts Android兼容性测试套件标准 dalvik dalvik虚拟机 developers 开发者目录 development 应用程序开发相关 device 设备相关配置 docs 参考文档目录 external 开源模组相关文件 frameworks 应用程序框架，Android系统核心部分，由Java和C++编写 hardware 主要是硬件抽象层的代码 libcore 核心库相关文件 libnativehelper 动态库，实现JNI库的基础 ndk NDK相关代码，帮助开发人员在应用程序中嵌入C/C++代码 out 编译完成后代码输出在此目录 packages 应用程序包 pdk Plug Development Kit 的缩写，本地开发套件 platform_testing 平台测试 prebuilts x86和arm架构下预编译的一些资源 sdk sdk和模拟器 system 底层文件系统库、应用和组件 toolchain 工具链文件 tools 工具文件 Makefile 全局Makefile文件，用来定义编译规则 从表可以看出，系统源码分类清晰，并且内容庞大且复杂。接下来分析packages中的内容，也就是应用层部分。 应用层部分应用层位于整个Android系统的最上层，开发者开发的应用程序以及系统内置的应用程序都是在应用层。源码根目录中的packages目录对应着系统应用层。它的目录结构如表所示。 /frameworks/base目录 描述 /frameworks/base目录 描述 api 定义API cmds 重要命令：am、app_proce等 core 核心库 data 字体和声音等数据文件 docs 文档 graphics 图形图像相关 include 头文件 keystore 和数据签名证书相关 libs 库 location 地理位置相关库 media 多媒体相关库 native 本地库 nfc-extras NFC相关 obex 蓝牙传输 opengl 2D/3D 图形API packages 设置、TTS、VPN程序 sax XML解析器 services 系统服务 telephony 电话通讯管理 test-runner 测试工具相关 tests 测试相关 tools 工具 wifi wifi无线网络 C/C++程序库部分系统运行库层（Native)中的 C/C++程序库的类型繁多，功能强大，C/C++程序库并不完全在一个目录中，这里给出几个常用且比较重要的C/C++程序库所在的目录位置。| 目录位置 | 描述 ||:—-:|:—-:|| bionic/ | Google开发的系统C库，以BSD许可形式开源。 || /frameworks/av/media | 系统媒体库 || /frameworks/native/opengl | 第三方图形渲染库 || /frameworks/native/services/surfaceflinger | 图形显示库，主要负责图形的渲染、叠加和绘制等功能 || external/sqlite | 轻量型关系数据库SQLite的C++实现 | 讲完 C/C++程序库部分，Android运行时库的代码放在art/目录中。硬件抽象层的代码在hardware/目录中，这一部分是手机厂商改动最大的一部分，根据手机终端所采用的硬件平台会有不同的实现。]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>Framework</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[移动零]]></title>
    <url>%2F2019%2F01%2F09%2F%E7%A7%BB%E5%8A%A8%E9%9B%B6%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：283 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 示例：12输入: [0,1,0,3,12]输出: [1,3,12,0,0] 说明： 必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。 最优解答：123456789101112public static void moveZeroes(int[] nums) &#123; int j = 0; for(int i = 0; i&lt;nums.length; i++)&#123; if(nums[i]!= 0)&#123; nums[j++] = nums[i]; &#125; &#125; while(j &lt; nums.length)&#123; nums[j] = 0; j++; &#125;&#125; 我的解答：12345678910111213141516171819public static void moveZeroes(int[] nums) &#123; int index = 0; for(int i = 0;i &lt; nums.length;i ++)&#123; if (nums[i] != 0) continue; index++; &#125; if (index == nums.length) return; for(int i = 0;i &lt; nums.length - 1;i ++)&#123; if (nums[i] != 0) continue; for (int j = i;j &lt; nums.length - 1;j ++)&#123; int temp = nums[j]; nums[j] = nums[j + 1]; nums[j + 1] = temp; &#125; if (nums[i] == 0 &amp;&amp; i &lt; (nums.length - index)) &#123; i--; &#125; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[加一]]></title>
    <url>%2F2019%2F01%2F08%2F%E5%8A%A0%E4%B8%80%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：66 给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。 示例 1:123输入: [1,2,3]输出: [1,2,4]解释: 输入数组表示数字 123。 示例2：123输入: [4,3,2,1]输出: [4,3,2,2]解释: 输入数组表示数字 4321。 提示：逢九进一，当数组下标为0时，数组长度扩增一位 我的解答： 1234567891011121314151617181920public static int[] plusOne(int[] digits) &#123; for (int i = digits.length -1;i &gt;= 0;i --)&#123; int number = digits[i] + 1; if (number == 10)&#123; digits[i] = 0; if (i == 0)&#123; int[] newArr = new int[digits.length + 1]; newArr[0] = 1; return newArr; &#125; &#125;else &#123; digits[i] = number; break; &#125; &#125; return digits;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[两个数组的交集 II]]></title>
    <url>%2F2019%2F01%2F07%2F%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E7%9A%84%E4%BA%A4%E9%9B%86%20II%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：350 给定两个数组，编写一个函数来计算它们的交集。 示例 1: 12输入: nums1 = [1,2,2,1], nums2 = [2,2]输出: [2,2] 示例 2: 12输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]输出: [4,9] 说明： 输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。 我们可以不考虑输出结果的顺序。 进阶: 如果给定的数组已经排好序呢？你将如何优化你的算法？ 如果 nums1 的大小比 nums2 小很多，哪种方法更优？ 如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？ 我的解答： 12345678910111213141516171819202122public static int[] intersect(int[] nums1, int[] nums2) &#123; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); List&lt;Integer&gt; numList = new ArrayList&lt;&gt;(); for (int num:(nums1.length&gt;=nums2.length?nums1:nums2))&#123; numList.add(num); &#125; for (int num:(nums1.length&lt;nums2.length?nums1:nums2))&#123; if (numList.contains(num))&#123; list.add(num); numList.remove(numList.indexOf(num)); &#125; &#125; int[] nums = new int[list.size()]; for (int i=0;i&lt;list.size();i++)&#123; nums[i] = list.get(i); &#125; return nums;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[只出现一次的数字]]></title>
    <url>%2F2019%2F01%2F05%2F%E5%8F%AA%E5%87%BA%E7%8E%B0%E4%B8%80%E6%AC%A1%E7%9A%84%E6%95%B0%E5%AD%97%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：136给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 说明： 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ 示例1：12输入: [2,2,1]输出: 1 示例2：12输入: [4,1,2,1,2]输出: 4 我的解答:1234567891011public int singleNumber(int[] nums) &#123; Map&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;(); for (int i=0;i&lt;nums.length;i++)&#123; if (map.containsKey(nums[i]))&#123; map.remove(nums[i]); &#125;else &#123; map.put(nums[i],nums[i]); &#125; &#125; return (int) map.keySet().toArray()[0];&#125; 最优方案(运用异或运算)1234567public int singleNumber(int[] nums) &#123; int result = nums[0]; for (int i=1;i&lt;nums.length;i++)&#123; result ^= nums[i]; &#125; return result;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[Flutter]]></title>
    <url>%2F2019%2F01%2F05%2FFlutter%2F</url>
    <content type="text"><![CDATA[Flutter框架结构 Flutter Framework这是一个纯 Dart实现的 SDK，它实现了一套基础库，自底向上，我们来简单介绍一下： 底下两层（Foundation和Animation、Painting、Gestures）在Google的一些视频中被合并为一个dart UI层，对应的是Flutter中的dart:ui包，它是Flutter引擎暴露的底层UI库，提供动画、手势及绘制能力。 Rendering层，这一层是一个抽象的布局层，它依赖于dart UI层，Rendering层会构建一个UI树，当UI树有变化时，会计算出有变化的部分，然后更新UI树，最终将UI树绘制到屏幕上，这个过程类似于React中的虚拟DOM。Rendering层可以说是Flutter UI框架最核心的部分，它除了确定每个UI元素的位置、大小之外还要进行坐标变换、绘制(调用底层dart:ui)。 Widgets层是Flutter提供的的一套基础组件库，在基础组件库之上，Flutter还提供了 Material 和Cupertino两种视觉风格的组件库。而我们Flutter开发的大多数场景，只是和这两层打交道。Flutter Engine这是一个纯 C++实现的 SDK，其中包括了 Skia引擎、Dart运行时、文字排版引擎等。在代码调用 dart:ui库时，调用最终会走到Engine层，然后实现真正的绘制逻辑。]]></content>
      <categories>
        <category>Flutter</category>
      </categories>
  </entry>
  <entry>
    <title><![CDATA[存在重复元素]]></title>
    <url>%2F2019%2F01%2F04%2F%E5%AD%98%E5%9C%A8%E9%87%8D%E5%A4%8D%E5%85%83%E7%B4%A0%2F</url>
    <content type="text"><![CDATA[LeetCode 题号：217 给定一个整数数组，判断是否存在重复元素。如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。 示例1: 12输入: [1,2,3,1]输出: true 示例2: 12输入: [1,2,3,4]输出: false 示例3: 12输入: [1,1,1,3,3,4,3,2,4,2]输出: true 解决方案: 解法一 解题思路：循环数组nums，通过map来检测是否存在重复元素 12345678910public boolean containsDuplicate(int[] nums) &#123; Map&lt;Integer,Integer&gt; map = new HashMap&lt;&gt;(); for (int i = 0; i &lt; nums.length; i ++)&#123; if (map.containsKey(nums[i]))&#123; return true; &#125; map.put(nums[i],nums[i]); &#125; return false;&#125; 解法二 解题思路：先将数组nums进行排序，再循环排序好的数组，从下标0和下标1比较，相同就存在重复，返回；不同的，则1和2比较，依次类推 12345678910111213public static boolean containsDuplicate(int[] nums) &#123; if (nums.length == 0) return false; Arrays.sort(nums); int num = nums[0]; for (int i=1;i&lt;nums.length;i++)&#123; if (nums[i] != num)&#123; num = nums[i]; &#125;else &#123; return true; &#125; &#125; return false;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[旋转数组]]></title>
    <url>%2F2019%2F01%2F03%2F%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%2F</url>
    <content type="text"><![CDATA[LeetCode题号:189 给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。 示例1: 123456输入: [1,2,3,4,5,6,7] 和 k = 3输出: [5,6,7,1,2,3,4]解释:向右旋转 1 步: [7,1,2,3,4,5,6]向右旋转 2 步: [6,7,1,2,3,4,5]向右旋转 3 步: [5,6,7,1,2,3,4] 示例2: 12345输入: [-1,-100,3,99] 和 k = 2输出: [3,99,-1,-100]解释: 向右旋转 1 步: [99,-1,-100,3]向右旋转 2 步: [3,99,-1,-100] 解决方案： 解法一 解题思路：copy数组nums，先将数组下标nums.length - k-1下标后的数组放到0到k-1位置，再将之前0到nums.length - k-1移动到k-1下标之后 1234567891011public static void rotate(int[] nums, int k) &#123; k = k % nums.length; int[] numsCopy = nums.clone(); for (int i=0;i&lt;nums.length;i++)&#123; if (i &lt; k)&#123; nums[i] = numsCopy[nums.length - k + i]; &#125;else &#123; nums[i] = numsCopy[i - k]; &#125; &#125;&#125; 解法二 解题思路：现在数组从0到nums.length - 1 - k进行旋转，再将旋转后的数组从nums.length - k,到nums.length -1，最后将整个数组进行旋转 1234567891011121314151617181920public static void rotate(int[] nums, int k) &#123; if (nums.length &lt; 2 || k &lt; 1 || k % nums.length == 0) return; if (k &gt; nums.length) k = k % nums.length; //1,2,3,4,5,6,7 reverse(nums, 0, nums.length - 1 - k); //4,3,2,1,5,6,7 reverse(nums, nums.length - k, nums.length -1); //4,3,2,1,7,6,5 reverse(nums, 0, nums.length - 1); //5,6,7,1,2,3,4&#125;private static void reverse(int[] nums, int start, int end) &#123; while (start &lt; end) &#123; int temp = nums[start]; nums[start++] = nums[end]; nums[end--] = temp; &#125;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[从排序数组中删除重复项]]></title>
    <url>%2F2019%2F01%2F03%2F%E4%BB%8E%E6%8E%92%E5%BA%8F%E6%95%B0%E7%BB%84%E4%B8%AD%E5%88%A0%E9%99%A4%E9%87%8D%E5%A4%8D%E9%A1%B9%2F</url>
    <content type="text"><![CDATA[LeetCode题号：26 给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 示例 1: 12345给定数组 nums = [1,1,2], 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 你不需要考虑数组中超出新长度后面的元素。 示例 2: 12345给定 nums = [0,0,1,1,1,2,2,3,3,4],函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。你不需要考虑数组中超出新长度后面的元素。 说明: 为什么返回数值是整数，但输出的答案是数组呢?请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。你可以想象内部操作如下: 12345678// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝int len = removeDuplicates(nums);// 在函数里修改输入数组对于调用者是可见的。// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。for (int i = 0; i &lt; len; i++) &#123; print(nums[i]);&#125; 输入[1,1,2] 预期输出[1,2] 我的答案 解法一 解题思路：循环数组nums,用list来过滤重复数据 1234567891011121314class Solution &#123; public int removeDuplicates(int[] nums) &#123; List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); for (int i =0;i &lt; nums.length;i++)&#123; if (!list.contains(nums[i]))&#123; list.add(nums[i]); &#125; &#125; for (int i = 0;i&lt; list.size();i++)&#123; nums[i] = list.get(i); &#125; return list.size(); &#125;&#125; 解法二 解题思路：因为数组nums是排序好的，循环nums，计算nums里有几个不同数字 1234567891011public static int removeDuplicates(int[] nums) &#123; if (nums.length == 0) return 0; int i = 0; for (int j = 1; j &lt; nums.length; j++) &#123; if (nums[i] != nums[j]) &#123; i++; nums[i] = nums[j]; &#125; &#125; return i + 1;&#125;]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[买卖股票的最佳时机 II]]></title>
    <url>%2F2019%2F01%2F03%2F%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BA%20II%2F</url>
    <content type="text"><![CDATA[LeetCode题号:122 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 示例 1:1234输入: [7,1,5,3,6,4]输出: 7解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。 示例2：12345输入: [1,2,3,4,5]输出: 4解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。 因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。 示例3：123输入: [7,6,4,3,1]输出: 0解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 解决方案1：12345678public int maxProfit(int[] prices) &#123; int value = 0; for (int i = 1; i &lt; prices.length; ++i) &#123; int money = prices[i] - prices[i - 1]; value += money &gt; 0 ? money : 0; &#125; return value;&#125; 当明天的价格比今天的价格贵的时候我们今天买，明天卖，这样能够获取最大利润]]></content>
      <categories>
        <category>算法</category>
      </categories>
      <tags>
        <tag>简单</tag>
        <tag>数组</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[自定义View之小试牛刀]]></title>
    <url>%2F2016%2F07%2F01%2F%E8%87%AA%E5%AE%9A%E4%B9%89View%E4%B9%8B%E5%B0%8F%E8%AF%95%E7%89%9B%E5%88%80%2F</url>
    <content type="text"><![CDATA[自定义View对于Android程序猿来说都应该了解的，或者说一定要掌握。虽然Google提供的控件可以满足日常开发需求，但是总有些奇葩需求肯定是满足不了的，所以对于自定义View的开发，就必不可少了。 关于自定义View的基础学习推荐GcsSloop自定义View系列 首先看下面效果图 实现上图的效果参考这篇文章 再来这个效果图 上面效果图是根据第一个Demo的扩展，具体源码会在文章结尾提供链接 最后一个效果图 这个自定义View是模仿QQ运动的那个界面 下面具体对模仿QQ运动这个View实现步骤1.初始化所需参数//数据初始化 private void init(Context context){ //圆弧所需的矩形 mRect = new RectF(); //其他字的画笔 textGrayPaint = new Paint(); textGrayPaint.setAntiAlias(true); textGrayPaint.setStyle(Paint.Style.FILL); textGrayPaint.setColor(0xFFC6C1C3); textGrayPaint.setTextAlign(Paint.Align.CENTER); //排名的画笔 textSmallPaint = new Paint(); textSmallPaint.setAntiAlias(true); textSmallPaint.setStyle(Paint.Style.FILL); textSmallPaint.setColor(textColor); textSmallPaint.setTextAlign(Paint.Align.CENTER); //总步数的画笔 textBigPaint = new Paint(); textBigPaint.setAntiAlias(true); textBigPaint.setStyle(Paint.Style.FILL); textBigPaint.setColor(textColor); textBigPaint.setTextAlign(Paint.Align.CENTER); //外圆弧的画笔 outSideLinePaint = new Paint(); outSideLinePaint.setAntiAlias(true); outSideLinePaint.setStyle(Paint.Style.STROKE); outSideLinePaint.setColor(outCircleColor); outSideLinePaint.setStrokeCap(Paint.Cap.ROUND); //内圆弧的画笔 inSideLinePaint = new Paint(); inSideLinePaint.setAntiAlias(true); inSideLinePaint.setStyle(Paint.Style.STROKE); inSideLinePaint.setColor(inCircleColor); inSideLinePaint.setStrokeCap(Paint.Cap.ROUND); //竖条画笔 barPaint = new Paint(); barPaint.setAntiAlias(true); barPaint.setStyle(Paint.Style.FILL); barPaint.setColor(outCircleColor); barPaint.setStrokeCap(Paint.Cap.ROUND); //背景画笔 backgroundPaint = new Paint(); barPaint.setAntiAlias(true); barPaint.setStyle(Paint.Style.FILL); //虚线画笔 dashLinePaint = new Paint(); dashLinePaint.setAntiAlias(true); dashLinePaint.setColor(Color.parseColor(&quot;#C1C1C1&quot;)); dashLinePaint.setStyle(Paint.Style.STROKE); dashLinePaint.setPathEffect(new DashPathEffect(new float[]{8, 4}, 0));//画虚线 //头像 headBitmap = BitmapFactory.decodeResource(context.getResources(),R.mipmap.icon_head); } 2.测量View的宽高//测量高度 private int getHeightMeasure(int measureSpec){ int result = getSuggestedMinimumHeight(); int specMode = MeasureSpec.getMode(measureSpec); int specSize = MeasureSpec.getSize(measureSpec); switch (specMode){ case MeasureSpec.UNSPECIFIED: break; case MeasureSpec.EXACTLY: case MeasureSpec.AT_MOST: result = (int) (specSize*0.7); break; } return result; } //测量宽度 private int getWidthMeasure(int measureSpec){ int result = getSuggestedMinimumWidth(); int specMode = MeasureSpec.getMode(measureSpec); int specSize = MeasureSpec.getSize(measureSpec); switch (specMode){ case MeasureSpec.UNSPECIFIED: break; case MeasureSpec.EXACTLY: case MeasureSpec.AT_MOST: result = (int) (specSize*0.9); break; } return result; } //计算所需各个数值大小 @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { super.onSizeChanged(w, h, oldw, oldh); width = w; height = h; centerX = 0; centerY = -height*heightScale; mRect = new RectF(-width*widthScale,-width*widthScale+centerY,width*widthScale,width*widthScale+centerY); arcStrokeWidth = width/200f*6; textGraySize = width/200f*7; textSmallSize = width/200f*8; textBigSize = textSmallSize*3; } 3.最后就是把界面画出来@Override protected void onDraw(Canvas canvas) { super.onDraw(canvas); //设置各个paint所需的大小 textGrayPaint.setTextSize(textGraySize); textSmallPaint.setTextSize(textSmallSize); textBigPaint.setTextSize(textBigSize); outSideLinePaint.setStrokeWidth(arcStrokeWidth); inSideLinePaint.setStrokeWidth(arcStrokeWidth); barPaint.setStrokeWidth(arcStrokeWidth); paintBelowBackground(canvas);//画下层背景 paintUpBackground(canvas);//画上层背景 paintDashLine(canvas);//画虚线 paintBar(canvas);//画近七天的竖条 paintBottom(canvas); canvas.translate(width/2,height/2); //移动坐标原点到中间 //画圆弧 Path path = new Path(); path.addArc(mRect,120,300); canvas.drawPath(path,inSideLinePaint); path.reset(); path.addArc(mRect,120,300*percent); canvas.drawPath(path,outSideLinePaint); //圆弧间的文字 textGrayPaint.setTextAlign(Paint.Align.CENTER); textGrayPaint.setTextSize(textGraySize); canvas.drawText(&quot;截至&quot;+nowTime+&quot;已走&quot;,0,-textBigSize+centerY,textGrayPaint); canvas.drawText(totalText+&quot;&quot;,0,textSmallSize/2+centerY,textBigPaint); canvas.drawText(&quot;好友平均&quot;+freAvgText+&quot;步&quot;,0,textBigSize+centerY,textGrayPaint); canvas.drawText(&quot;第&quot;,-textSmallSize/2*3+centerX,width*widthScale+centerY,textGrayPaint); canvas.drawText(rankText+&quot;&quot;,0+centerX,width*widthScale+centerY,textSmallPaint); canvas.drawText(&quot;名&quot;,textSmallSize/2*3+centerX,width*widthScale+centerY,textGrayPaint); } 上面只放了部分代码，完整代码地址 PS：模仿QQ运动这个只画出了界面，没有给出点击事件，有兴趣的同学可以自行浏览体验]]></content>
      <categories>
        <category>Android</category>
      </categories>
      <tags>
        <tag>View</tag>
      </tags>
  </entry>
  <entry>
    <title><![CDATA[TCP的连接和释放]]></title>
    <url>%2F2016%2F06%2F17%2FTCP-IP%E7%9A%84%E8%BF%9E%E6%8E%A5%E5%92%8C%E9%87%8A%E6%94%BE%2F</url>
    <content type="text"><![CDATA[TCP传输控制协议，是一个面向连接的协议。在运用此协议进行数据传输前都会进行连接的建立工作（三次握手）；当数据传输完毕，连接的双方都会通知对方要释放此连接（四次挥手）。 认识TCP标志位SYN(synchronous建立联机) ACK(acknowledgement 确认) PSH(push传送) FIN(finish结束) RST(reset重置) URG(urgent紧急) 三次握手 第一次握手：客户端发送一个TCP标志位SYN=1，ACK=0的数据包给服务端，并随机会产生一个Sequence number=3233.当服务端接收到这个数据后，服务端由SYN=1可知客户端是想要建立连接； 第二次握手：服务端要对客户端的联机请求进行确认，向客户端发送应答号ACK=1、SYN=1确认号Acknowledge number=3234，此值是客户端的序列号加1，还会产生一个随机的序列号Sequence number=36457，这样就告诉客户端可以进行连接； 第三次握手：客户端收到数据后检查Acknowledge number是否是3233+1的值，以及ACK的值是否为1，若为1，host1会发送ACK=1、确认号码Acknowledge number=36457，告诉服务端,你的请求连接被确认，连接可以建立。 四次挥手 第一次挥手：当传输的数据到达尾部时，客户端向服务端发送FIN=1标志位；可理解成，客户端向服务端说，我这边的数据传送完成了，我准备断开了连接； 第二次挥手：因TCP的连接是全双工的双向连接，关闭也是要从两边关闭；当服务端收到客户端发来的FIN=1的标志位后，服务端不会立刻向客户端发送FIND=1的请求关闭信息，而是先向客户端发送一个ACK=1的应答信息，表示：你请求关闭的请求我已经收到，但我可能还有数据没有完成传送，你再等下，等我数据传输完成了我就告诉你； 第三次挥手：服务端数据传输完成，向客户端发送FIN=1，客户端收到请求关闭连接的请求后，客户端就明白服务端的数据已传输完成，现在可以断开连接了， 第四次挥手：客户端收到FIND=1后，客户端还是怕由于网络不稳定的原因，怕服务端不知道他要断开连接，于是向服务端发送ACK=1确认信息进行确认，把自己设置成TIME_WAIT状态并启动定时器，如果服务端没有收到ACK，服务端TCP的定时器到达后，会要求客户端重新发送ACK，当服务端收到ACK后，服务端就断开连接；当客户端等待2MLS（2倍报文最大生存时间）后，没有收到服务端的重传请求后，他就知道服务端已收到了ACK，所以客户端此时才关闭自己的连接。]]></content>
      <categories>
        <category>通信协议</category>
      </categories>
      <tags>
        <tag>TCP</tag>
      </tags>
  </entry>
</search>