【2017.12.5】6.ZigZag Conversion(曲折转换)_zigzag参数有9 3 3,12 3 3-CSDN博客

本文链接：https://blog.csdn.net/qq_31060183/article/details/78742914

6.1 ZigZag Conversion

打印时出现的字符图案
ZigZag的意识就是把字符串的顺序012345….按下图所示的排序

这里写图片描述

6.2 String[] ans = new String[nRows];

java 创建数组：使用new创建数组对象但是分配数组是会自动为数组分配默认值

6.2.1 一维数组的声明方式

type[] arrayName; //推荐
type arrarNamep[];

声明数组

     // 声明整型数组
     int[] intArray0 ;
     int intArray1 [];
     // 声明浮点型数组
     float floatArray0 [];
     float[] floatArray1 ;
     // 声明布尔型数组
     boolean boolArray0 [];
     boolean[] boolArray1 ;
     // 声明字符型数组
      char charArray0 [];
     char[] charArray1 ;
     // 声明字符串数组
     String stringArray0[];
     String[] stringArray1;
     // 错误的声明数组的方式，声明数组的时候不能指定其大小
     // int [5] intErrorArray0;
      // int intErrorArray1[5];

注：
java语言中声明数组不嫩制定其长度，这是因为数组是一种引用类型的变量，因此使用它定义一个变量是，仅仅表示定义了一个引用变量（也就是定义了一个指针），这个引用变量还未指向任何有效的内存，所以定义数组时不能指定数组的长度。
而且由于定义数组仅仅只是定一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有在数组进行初始化后才可以使用。

6.2.2 一维数组的创建

Java中使用关键字new创建数组对象，格式为：

数组名 = new 数组元素的类型 [数组元素的个数

     // 创建数组，如果在创建的同时不初始化数组则必须指定其大小
     intArray0 = new int[3];
     // 错误的创建数组的方式，如果创建数组时不指定大小则必须初始化
     // intArray1 = new int[];
     // 创建数组时，不指定数组大小则必须在创建的同时初始化数组
      intArray1 = new int[]{0,1,2};
       使用new创建数组对象但是分配数组时会自动为数组分配默认值，具体如下：
     System.out.println( "intArray0[0]=" + intArray0 [0]);
     floatArray0 = new float[3];
     System. out.println("floatArray0[0]=" + floatArray0[0]);
     boolArray0 = new boolean[3];
     System. out.println("boolArray0[0]=" + boolArray0[0]);
     charArray0 = new char[3];
     System. out.println("charArray0[0]=" + charArray0[0]);
     stringArray0 = new String[3];
     System. out.println("stringArray0[0]=" + stringArray0[0]);

    //输出如下：
     intArray0[0]=0
     floatArray0[0]=0.0
     boolArray0[0]=false
     charArray0[0]=
     stringArray0[0]=null

6.2.3 一维数组的初始化

a、数组静态初始化的语法格式：

arrayName = new type[]{element1,element2,element3…}

或者使用简化的语法格式：arrayName = {element1,element2,element3…}

b、数组动态初始化的语法格式：

arrayName = new type[length]；

静态数组初始化的时候不能指定元素的个数，而的动态初始化是必须指定元素的个数。静态初始化时数组能够知道元素的个数所以不需要指定，而动态初始化是数组元素的个数未知因此必须指定。


     // 静态初始化
     int intArray2 [] = new int[]{20,21,22};
      // 静态初始化简化方式
     int intArray3 [] = {30,31,32};
      // 动态初始化
     int[] intArray4 = new int[3]; 

      // 错误写法：静态初始化不能指定元素个数
     // int intErrorArray5[] = new int[3]{50,51,52};
     // 错误写法：动态初始化必须指定元素个数
     // int intErrorArray6[] = new int[];

整合

package javabase;

public class CreateArray {
       public static void main(String args[]){
             /**************数组的声明*******************/
             // 声明整型数组
             int[] intArray0 ;
             int intArray1 [];
             // 声明浮点型数组
             float floatArray0 [];
             float[] floatArray1 ;
             // 声明布尔型数组
             boolean boolArray0 [];
             boolean[] boolArray1 ;
             // 声明字符型数组
             char charArray0 [];
             char[] charArray1 ;
             // 声明字符串数组
            String stringArray0[];
            String[] stringArray1;
             // 错误的声明数组的方式，声明数组的时候不能指定其大小
             // int [5] intErrorArray0;
             // int intErrorArray1[5];

             /*********************数组的创建***********************/
             // 创建数组，如果在创建的同时不初始化数组则必须指定其大小
             intArray0 = new int[3];
             // 错误的创建数组的方式，如果创建数组时不指定大小则必须初始化
             // intArray1 = new int[];
             // 创建数组时，不指定数组大小则必须在创建的同时初始化数组
             intArray1 = new int[]{0,1,2};
            System. out.println("intArray0[0]=" + intArray0[0]);
             floatArray0 = new float[3];
            System. out.println("floatArray0[0]=" + floatArray0[0]);
             boolArray0 = new boolean[3];
            System. out.println("boolArray0[0]=" + boolArray0[0]);
             charArray0 = new char[3];
            System. out.println("charArray0[0]=" + charArray0[0]);
             stringArray0 = new String[3];
            System. out.println("stringArray0[0]=" + stringArray0[0]);

             /**********************数组的初始化*************************/
             // 静态初始化
             int intArray2 [] = new int[]{20,21,22};
             // 静态初始化简化方式
             int intArray3 [] = {30,31,32};
             // 动态初始化
             int[] intArray4 = new int[3];

             // 错误写法：静态初始化不能指定元素个数
             // int intErrorArray5[] = new int[3]{50,51,52};
             // 错误写法：动态初始化必须指定元素个数
             // int intErrorArray6[] = new int[];

            System. out.println("intArray2[0]=" +intArray2 [0]);
            System. out.println("intArray3[0]=" +intArray3 [0]);
            System. out.println("intArray4[0]=" +intArray4 [0]);
      }
}

6.3 array.fill()方法

Fill public static void fill(Object[] a, int fromIndex, int toIndex, Object val)
将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。
（如果 fromIndex==toIndex，则填充范围为空。）

参数：
a - 要填充的数组
fromIndex - 要使用指定值填充的第一个元素的索引（包括）
toIndex - 要使用指定值填充的最后一个元素的索引（不包括）
val - 要存储在数组的所有元素中的值

举几个例子：

Arrays.fill（ a1, value ）;
//a1是一个数组变量，value是一个a1中元素数据类型的值，作用：填充a1数组中的每个元素都是value
boolean[] a1 = new boolean[5];
Arrays.fill( a1,true );
//结果 a1[] = {true,true,true,true,true};


String[] a = new String[6];
Arrays.fill(a, "Hello");
Arrays.fill(a, 3, 5,"World");
//结果是 a[] = {Hello,Hello,Hello,World,World,Hello};

第一个参数指操作的数组，第二个和第三个指在该数组的某个区域内插入第四个参数.

一定要注意:
1.java的数组下标从0开始
2.第二个参数指起始元素下标(包括该下标)
3.第三个参数指结束下标(不包括该下标)

———————分割线啦—————————————————————————-

6. ZigZag Conversion

题目：

The string “PAYPALISHIRING” is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
你可能想要一个固定的字体来显示这个图案，以便更好的可读性

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

And then read line by line: “PAHNAPLSIIGYIR”

Write the code that will take a string and make this conversion given a number of rows:

string convert(string text, int nRows);

convert(“PAYPALISHIRING”, 3) should return “PAHNAPLSIIGYIR”.

code：

approach 1

class Solution {
    public String convert(String s, int numRows) {

        int len = s.length();
        if( len == 0 || numRows <= 1 ) return s;

        //定义一个 numRows 长度的String数组，存放每一行的结果
        //用一个字符串数组string[rows]来存储每一行，最后一拼接就是最终结果
        String[] ans = new String[numRows];
        //填充ans为空
        Arrays.fill(ans,"");
        //使用delta来表示正想还是反响，即是从第一行到最后一行，还是最后一行到第一行。
        int row = 0, delta =1;
        for(int i = 0;i < len;i++){
            ans[row] += s.charAt(i);
            row += delta;
            if (row >= numRows ){
                row = numRows -2;
                delta = -1;
            }
            if(row<0){
                row = 1;
                delta = 1;
            }
        }

        String ret ="";
        for(int i = 0 ; i < numRows; i++){
            ret += ans[i];
        }
        return ret;

    }
}

Appraoch 2

class Solution {
    public String convert(String s, int numRows) {
        int len  = s.length();
        //如果字符串长度为0 ， 或者 只要求0或1行输出的话，返回字符串s
        if(len == 0 || numRows < 2) return s;

        //利用所有行的重复周期为 2*numRows -2
        //对于首行和末行之间的行，还有额外重复一次，重复的这一次距离本周起始字符的距离是 2*numRows-2-2*i
        String ret ="";
        int lag = 2*numRows-2;//循环周期
        for(int i=0; i<numRows;i++){
            for(int j=i;j<len;j+=lag){
                ret += s.charAt(j);

                //非首行和末行是还要加一个
                if(i>0 && i<numRows-1){
                    int t=j+lag-2*i;
                    if(t<len){
                        ret += s.charAt(t);
                    }
                }
            }
        }
        return ret;
    }
}