Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment

距离上一篇博客更新已经小半年了，这期间我懒懒散散，整天沉迷于Wi-Fi暴力破解、VPS的shadowsocks配置、搭建私有云之类的奇技淫巧，深刻领悟了Linux的魅力，也终于迫于找实习的压力重新开始写代码，更博客。其实上一篇博客之后，原本有一些笔试大题的解答，但那时我还没有学得算法的皮毛，净是些暴力方法，写着写着烂尾了不好意思发布出来。等我最近学习算法的期间若想到了更好的解法，便一并贴出。

前几天在写WORKS APPLICATIONS的两题笔试题，就没空写博客了。现在写完了，先分享一下第一个题Magic Cube里遇到的知识点“引用和clone方法”。详细的题解请关注后续博客。

先来说说我是怎么遇到这个知识点的，在解题过程中，我写了一个包含三维数组的类和一个递归方法，大概如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class Cube{
    private int len;		//立方体边长
    private int[][][] cells;//立方体点阵
  
    public Cube(int len, int[][][] cells) {
        this.len = len;
        this.cells = cells;
    }
  
    //省略一些代码	
  
    public static void main(String[] args) {
        //省略一些代码
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        Cube[] smallCubes = new Cube[N];
        for (int i = 0; i < N; i++) {
            int len = sc.nextInt();
            Ns = new int[len][len][len];
System.out.println(Ns);//获取Ns的哈希码
            for (int j = 0; j < len; j++) {
                for (int k = 0; k < len; k++) {
                    for (int l = 0; l < len; l++) {
                        Ns[j][k][l] = sc.nextInt();
                    }
                }
            }
            smallCubes[i] = new Cube(len, Ns);
System.out.println(smallCubes[i].cells);//获取smallCubes[i].cells的哈希码
        }
    }
}

运行后会发现两次输出的哈希码一样，如果有多组数据（N>1），那么你会发现每组数据输出两个相同的哈希码，组与组之间的哈希码不同。每组数据同样是Ns，地址却不同，这是为什么呢？别急，我们先保留这个疑惑，看看下面的情况。

因为解题需求，这时候我需要复制一个立方体：

昨天说的要更深入地探究一下Java反射，看了嘟嘟MD 前辈的这篇文章Java基础与提高干货系列——Java反射机制顿时神清气爽，觉得没多大必要再重复写他写过的了。所以今天就改成详细讲解反射的一众方法好了。

先补充一下昨天所讲的创建 Class 对象的方法，其实一共有三种（昨天漏说了第三种，代码引用自嘟嘟MD）：

1
2
3
4
5
6

//这说明任何一个类都有一个隐含的静态成员变量class，这种方式是通过获取类的静态成员变量class得到的
Class c1 = Code.class;
//code1是Code的一个对象，这种方式是通过一个类的对象的getClass()方法获得的
Class c2 = code1.getClass();
//这种方法是Class类调用forName方法，通过一个类的全量限定名获得
Class c3 = Class.forName("com.trigl.reflect.Code");

这学期刚开学的时候在睿思(我们学校的BBS)上看到了一个学长的求助，就收藏了，那时候自己还在搭建Hexo博客，没时间研究，昨天就去翻看了一下，原题如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class A {
    protected String getString() {
        return "A";
    }
}
public class B extends A {
    protected String getString() {
        return "B";
    }
}
public class C extends B {
}

要求在子类C的对象中访问其父类的父类A中的getString方法。

锯齿形转换

字符串“PAYPALISHIRING”以给定数字的行数被写入锯齿形图案：

1
2
3

P   A   H   N
A P L S I I G
Y   I   R

然后逐行读取得“PAHNAPLSIIGYIR”。

给定一个字符串，并给出了一个行数，

string convert(string text, int nRows);

如convert(“PAYPALISHIRING”, 3)这个转换应返回“PAHNAPLSIIGYIR”。

最长回文字符子串

给定一个字符串S，找出S中最长的回文字符子串。

一开始我想用递归，现检验整个字符串longestPalindrome(String s)，若非回文字，则调用自身，传入s.subString(1, s.length)和s.subString(0, s.length - 1)，即不断的左减一，右减一，检验其子串是否回文字。但是我想不好怎么接收return值，所以就用了很水的方法来检验，即对于遍历的每一个字符，检查其左右是否为回文字，这样的回文字判断也分奇数长度的和偶数长度的，如“121”和“1221”。具体实现代码如下：

今天晚上做了一下LeetCode上的Median of Two Sorted Arrays这道题，没想到一次性通过了。随即想要归纳整理一下排序算法，废话少说，我们开始吧。

选择排序

这是一种最简单直观的排序算法，它的工作原理如下：每一趟从待排序的数列中选出最小的（最大的）一个元素，顺序放到已经排好序的数列的最后，直到所有待排元素全部排好。选择排序是稳定的排序算法，最坏时间复杂度是O(n^2)，最优时间复杂度是O(n^2)，平均时间复杂度是O(n^2)。

下面是对{1, 3, 5, 7, 9, 2, 4, 6, 8, 0}进行选择排序的具体过程

最长无重字符子串

给定一个字符串，找到最长子串的长度不重复的字符。

例子：

给定“abcabcbb”，答案是“abc”，它的长度为3。

给定“bbbbb”，答案为“b”，长度为1。

给定“pwwkew”，答案是“wke”，长度为3。

注意答案一定是一个字符串的长度，“pwke”是一个序列，而不是子串。