题目

将字符串 "PAYPALISHIRING"以Z字形排列成给定的行数：

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

之后从左往右，逐行读取字符："PAHNAPLSIIGYIR"

实现一个将字符串进行指定行数变换的函数:

string convert(string s, int numRows);
示例 1:

输入: s = "PAYPALISHIRING", numRows = 3
输出: "PAHNAPLSIIGYIR"
示例 2:

输入: s = "PAYPALISHIRING", numRows = 4
输出: "PINALSIGYAHRPI"
解释:

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

分析

这道题乍一看有点难，其实很简单，通过率也是高达30%，单纯总结规律就能解答~~

• 想法一：第一次的想法是每个V型为一组，然后根据组来计算每一行的个数进而计算出每一行中每个字符的下标。
  后来被我否定了，明明之中觉得复杂度偏高。
• 想法二：直接一行一行来算数组下标。
  通过分析我们不难发现下标规律：
• 行数为四的时候：
  • 第一行：0 - 6 - 12 - 18 ... //步长6 6 6
  • 第二行：1 - 5 - 7 - 11 - 13 ... //步长4 2 4 2
  • 第三行：2 - 4 - 8 - 10 - 14 ... //步长2 4 2 4
  • 第四行：3 - 9 - 15 - 21 ... //步长6 6 6

规律显而易见，当然读者可以自己多试试其他的例子来验证。其实根据"Z"字的特点我们也能直接分析出这样的规律。接下来就是将规律函数化。

1. 步长：上述例子中 无论是6 还是4，2交替还是2，4交替，都是和6相关的。那么6又是怎么和层数关联呢？根据图形"Z"来分析，每加1层就会增加2步长，那么步长即为总层数*2-2，后文称之为绝对步长。
2. 根据步长我们能很快计算第一层的所有下标。那第二层 第n层呢。第二层其实就是步长-2，2交替，第三层是步长步长-4,4交替。
   提炼公式：步长- 2*(层数-1),2*(层数-1)交替。
   当然，最后一层和第一层步长一直都是绝对步长。
   接下来就是编码

    public String convert(String s, int numRows) {
        char[] c = new char[s.length()];
        int size = numRows * 2 - 2; //绝对步长
        int index; //记算s下标
        int count = 0; //记录c下标
        int add; //相对步长
        if (numRows < 2) {
            return s;
        }
        for (int i = 0; i < numRows; i++) { //一层一层遍历
            index = i;
            add = i * 2;
            while (index < c.length) { //超出字符串长度计算下一层
                c[count] = s.charAt(index);
                add = size - add;
                index += add == 0 ? size : add;
                count++;
            }
        }
        return new String(c);
    }

运行很轻松就通过啦~~

比较

还是老规矩，拷贝速度排行第一的算法进行比较

    public String convert1(String s, int numRows) {
        if(numRows < 2) {
            return s;
        }
        StringBuilder result = new StringBuilder();
        int group = 2 * numRows - 2;
        for(int i = 1; i <= numRows; i ++) {
            int interval = 2 * numRows - 2 * i;
            if(i == numRows) {
                interval = 2 * numRows - 2;
            }
            int index = i;
            while(index <= s.length()) {
                result.append(s.charAt(index - 1));
                index += interval;
                interval = group - interval;
                if(interval == 0) {
                    interval = group;
                }
            }
        }
        return result.toString();
    }

单纯从代码上看，感觉应该不是算法王者的代码，很多优化点，最明显的就是StringBuilder构造时候应该传入s长度，不然默认容量是16，然后字符串过长的时候会不断出发扩容方法，调用多次Arrays.copy，上一篇的王者好像也是调用了多测Arrays.copy... 写道这里我有点怀疑自己从前的认知。。。从逻辑上看和我的逻辑有很多相似之处~~
好我们来跑一下代码看一下时间差：
字符串为随机字符串。

测试1

测试2

嗯 果然leedcode测试用例不够极端哈哈哈哈。然后我们稍微改进一下王者的代码。只修改StringBuilder容量那部分。

改进