<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[ONE_PIECE的专栏]]></title><description><![CDATA[Good good study]]></description><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; ONE_PIECE_HMH]]></copyright><item><title><![CDATA[剑指offer之找出数组中最小的n个数，之优先队列]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80486998</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80486998</guid><author>ONE_PIECE_HMH</author><pubDate>Mon, 28 May 2018 18:43:36 +0800</pubDate><description><![CDATA[这道题最简单的就是排序，时间复杂度O（nlogn）。不再讲述。这里可以使用优先队列，时间复杂度O（nlogk）。注意检验k的合法性，不然初始化队列时会报错。import java.util.ArrayList;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Queue;

public ...]]></description><category></category></item><item><title><![CDATA[剑指offer之找出无序数组中出现次数超过一半的数字]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80485276</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80485276</guid><author>ONE_PIECE_HMH</author><pubDate>Mon, 28 May 2018 18:00:11 +0800</pubDate><description><![CDATA[最简单也最容易想到的做法，就是先排序，如果存在的话，中间的数字肯定是要求的数字，然后再遍历一遍数组进行验证即可。但是这种做法，时间复杂度是O(nlogn）。import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;

public class...]]></description><category></category></item><item><title><![CDATA[剑指offer之字符串全排列]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80484757</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80484757</guid><author>ONE_PIECE_HMH</author><pubDate>Mon, 28 May 2018 17:00:50 +0800</pubDate><description><![CDATA[递归思想，把每个位置和后面的字符交换，即形成一个子排列。import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;

public class Solution {
  public ArrayList&amp;lt;String&amp;gt; Permutation(String str){
    A...]]></description><category></category></item><item><title><![CDATA[剑指offer之二叉搜索树转双向链表]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80483327</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80483327</guid><author>ONE_PIECE_HMH</author><pubDate>Mon, 28 May 2018 15:50:42 +0800</pubDate><description><![CDATA[这道题，比较容易想到和中序遍历有关，毕竟中序遍历的顺序，即是排序好的二叉搜索树，重点在于如何改变二叉树的节点指向，这里使用一个前任节点，用来指向当前想成的有序链表的最后一个节点（可以这么理解）。每次遍历的时候改变指向即可。/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right...]]></description><category></category></item><item><title><![CDATA[剑指offer之复杂链表的复制]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80185638</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/80185638</guid><author>ONE_PIECE_HMH</author><pubDate>Thu, 03 May 2018 20:30:41 +0800</pubDate><description><![CDATA[这道题一定要注意括号里面的东西，（输出结果中请不要返回参数中的节点引用）。也就是说，最后的返回的链表中的节点一定不能和原来链表中的某个节点指向同一个节点，即不能引用。所以必须分三步进行处理：1、复制每个节点，如：复制节点A得到A1，将A1插入节点A后面 2、遍历链表，A1-&amp;gt;random = A-&amp;gt;random-&amp;gt;next; 3、将链表拆分成原链表和复制后的链表代码如下：/*
p...]]></description><category></category></item><item><title><![CDATA[二叉树路径和为一固定值]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79897084</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79897084</guid><author>ONE_PIECE_HMH</author><pubDate>Sat, 14 Apr 2018 20:49:07 +0800</pubDate><description><![CDATA[二叉树类题目，第一反应肯定就是使用递归（dfs）。这道题也不例外。还是先给出我的代码。主要注意数组的引用性。所以每次都要去掉尾数。并在最后放入结果集中时，执行深copy。import java.util.ArrayList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode rig...]]></description><category></category></item><item><title><![CDATA[判断一个数组是不是二叉搜索树的后序遍历]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79886865</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79886865</guid><author>ONE_PIECE_HMH</author><pubDate>Wed, 11 Apr 2018 09:02:37 +0800</pubDate><description><![CDATA[这道题，首先，最重要的是。我们必须知道什么是二叉搜索树。这里给出百科：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。然后问题就很明显了。肯定是前面一部分都...]]></description><category></category></item><item><title><![CDATA[二叉树层次遍历]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79802838</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79802838</guid><author>ONE_PIECE_HMH</author><pubDate>Tue, 03 Apr 2018 14:28:23 +0800</pubDate><description><![CDATA[这题没啥说的，借助一个队列就行了。但是由于我个人对于java的队列用的不是很好。用C++的queue思想写的，结果并不一样。注意java的collection的通用操作。add()和isEmpty()。queue的实现等。import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
/**
publ...]]></description><category></category></item><item><title><![CDATA[判断一个序列是否是另外一个序列的出栈顺序]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79789693</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79789693</guid><author>ONE_PIECE_HMH</author><pubDate>Mon, 02 Apr 2018 15:11:11 +0800</pubDate><description><![CDATA[这道题其实也很简单。因为没有相等的数字。所以碰见相等就出栈。不等就入栈就行。最后还有元素，序列就肯定不对。import java.util.*;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
      if(null == pushA){
          return tr...]]></description><category></category></item><item><title><![CDATA[模拟最小栈]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79787064</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79787064</guid><author>ONE_PIECE_HMH</author><pubDate>Mon, 02 Apr 2018 11:54:10 +0800</pubDate><description><![CDATA[这个题其实很简单。最简单和最容易想的当然就是暴力了啊。也就是我的思路。import java.util.Stack;

public class Solution {

    Stack&amp;lt;Integer&amp;gt;  stacks = new Stack&amp;lt;&amp;gt;();
    public void push(int node) {
        stacks.push(node);...]]></description><category></category></item><item><title><![CDATA[顺时针打印矩阵]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79761181</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79761181</guid><author>ONE_PIECE_HMH</author><pubDate>Fri, 30 Mar 2018 17:53:01 +0800</pubDate><description><![CDATA[这道题感觉没什么特殊的技巧，但是坑点比较多。首先要注意下标越界。其实注意下标在临界处的增减问题。import java.util.ArrayList;
public class Solution {
    public ArrayList&amp;lt;Integer&amp;gt; printMatrix(int [][] matrix) {
        ArrayList&amp;lt;Integer&amp;gt; ...]]></description><category></category></item><item><title><![CDATA[判断B是否是A的子二叉树]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79748522</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79748522</guid><author>ONE_PIECE_HMH</author><pubDate>Thu, 29 Mar 2018 21:25:19 +0800</pubDate><description><![CDATA[这道题首先被一句话影响了。前序或者后序遍历，加上中序遍历可以确定一颗二叉树。这句话不假。但是我想当然的认为一个树的前序和中序都是。另外一个树的前序和中序的子序列。那就是子树。实际上随便画画就不对。比如{8，8,7,9,2，#，#，#，4,7}和{8,9,2}很明显就不对。然后就写了一个暴力递归。拿树A的每一个子树和树B做比较，如果每个节点都相等。则是子树。这里注意一点的是。树B到达尾节点的时候。树...]]></description><category></category></item><item><title><![CDATA[合并两个递增链表]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79745137</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79745137</guid><author>ONE_PIECE_HMH</author><pubDate>Thu, 29 Mar 2018 16:42:40 +0800</pubDate><description><![CDATA[由于递归思想没有根深蒂固，所以想了很久想到了一个非递归版本的。写的时候，由于java不是很好，一直在纠结java的赋值的引用性。其实不用纠结。再次赋值时，就指向另外的引用了，相互之间其实没有影响。/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        thi...]]></description><category></category></item><item><title><![CDATA[反转链表之java的copy。]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79740111</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79740111</guid><author>ONE_PIECE_HMH</author><pubDate>Thu, 29 Mar 2018 15:20:21 +0800</pubDate><description><![CDATA[这道题，我依然用的最暴力的方法，相当于重新构造了一个链表。因为之前写C++比较多，对于java的基础不是很好，这里因为要用到copy。用C++的链表思维理解可能会有偏差，这里简单讲一下java的三种copy：将一个对象的引用复制给另外一个对象，一共有三种方式。第一种方式是直接赋值，第二种方式是浅拷贝，第三种是深拷贝。所以大家知道了哈，这三种概念实际上都是为了拷贝对象啊。1、直接赋值。在Java中，...]]></description><category></category></item><item><title><![CDATA[求链表中第k个节点]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79734040</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79734040</guid><author>ONE_PIECE_HMH</author><pubDate>Wed, 28 Mar 2018 22:11:15 +0800</pubDate><description><![CDATA[这道题做法有很多种，首先讲一下像我这种脑子不是很好使的直白的做法。当然是先循环求出长度，再循环找到倒数第k个节点，即整数的n-k+1。/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public c...]]></description><category></category></item><item><title><![CDATA[数值的整数次方之快速幂]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79725116</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79725116</guid><author>ONE_PIECE_HMH</author><pubDate>Wed, 28 Mar 2018 12:28:29 +0800</pubDate><description><![CDATA[这道题最简单的做法就是调用库函数，而且牛客上能AC。感觉不是这道题的考点，也有可能是牛客的时间卡的不够严格，就特意研究了下java的pow函数，据说内部也是用的移位实现，可见效率和快速幂应该差不太远。但是快速幂还是要掌握下。public class Solution {
    public double Power(double base, int exponent) {
        ret...]]></description><category></category></item><item><title><![CDATA[求一个数n中1的个数]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79700634</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79700634</guid><author>ONE_PIECE_HMH</author><pubDate>Mon, 26 Mar 2018 17:27:59 +0800</pubDate><description><![CDATA[这道题可以说是很经典的一道题了，大部分人应该会顺手想到n&amp;amp;(n-1)。但是不知道有人和我一样，好久没做题，只想到n&amp;amp;(n-1)。就是想不起来怎么求1的个数了。做法一：于是乎，先写了一个这样的常规思路代码。public class Solution {
    public int NumberOf1(int n) {
        if( 0 == n)
            ...]]></description><category></category></item><item><title><![CDATA[矩形覆盖]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79697725</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79697725</guid><author>ONE_PIECE_HMH</author><pubDate>Mon, 26 Mar 2018 14:41:57 +0800</pubDate><description><![CDATA[这道题，智商高些的大佬，可能分分钟就解决了，但是浪费了半天的时间。一开始想的肯定是这类题，要找规律，从一开始计算。然后就先找到n = 4的情况。然后突然想到f(4) = f(3) * 2;然后发现并不对。然后看到结果是少了，就想到肯定有重复。然后想到。f(4) = f(3) * 2 - f(2) + f(1)；然后还是不对，这时候通过几次尝试的结果错误提示。瞎猜了下是f(4) = f(3) + f...]]></description><category></category></item><item><title><![CDATA[变态跳台阶]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79659903</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79659903</guid><author>ONE_PIECE_HMH</author><pubDate>Thu, 22 Mar 2018 21:12:12 +0800</pubDate><description><![CDATA[这题有多种做法，这里主要讲其中的两种。1、组合数学思想。除了最后一个台阶必须跳之外，其余的台阶我们既可以选择跳，也可以选择不跳，这样就是每个位置有两种选择，答案就是2^(n-1)。public class Solution {
    public int JumpFloorII(int target) {
       
        return 1&amp;lt;&amp;lt;(target-1);
 ...]]></description><category></category></item><item><title><![CDATA[旋转数组的最小数字]]></title><link>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79637881</link><guid>https://blog.youkuaiyun.com/ONE_PIECE_HMH/article/details/79637881</guid><author>ONE_PIECE_HMH</author><pubDate>Wed, 21 Mar 2018 12:16:55 +0800</pubDate><description><![CDATA[这道题最简单的做法，就是采取逆向思维。找第一个小于左边数字的数字，一定是最小的数字。因为本身是非递减排序数组。如果不存在这样一个数字，则说明这个数组肯定是正常的非递减排序数组，没有进行旋转。则最小数字肯定是第一个数字。import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(i...]]></description><category></category></item></channel></rss>