ZigZag Conversion1

问题描述

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"

string convert(string text, int nRows);

convert("PAYPALISHIRING", 3)

should return

"PAHNAPLSIIGYIR"

.

算法

代码：

/*
*
* 0A     8I     16Q     24Y
* 1B  7H 9J  15P17R  23X25Z
* 2C 6G 10K 14O 18S 22W
* 3D5F  11L13N  19T21V
* 4E    12M     20U
*/
public class ZigZagConversion {
public String convert(String s,int numRows){
if(s.length()<=numRows||numRows==1)
return s;
StringBuilder []res=new StringBuilder[numRows];
for(int i=0;i<numRows;i++)
res[i]=new StringBuilder();
int loop=2*numRows-2;
int mid=numRows-1;
for(int i=0;i<s.length();i++){
res[mid-Math.abs(i%loop-mid)].append(s.charAt(i));
}
for(int i=1;i<numRows;i++)
res[0].append(res[i]);
return res[0].toString();

}

}

注意事项：

1.对字符串的每个字符操作可以用toCharArray()得到一个char数组，也可以转换为StringBuffer对象或者StringBuilder对象，区别如下：

StringBuffer类

/**
* A thread-safe, mutable sequence of characters.
* A string buffer is like a {@link String}, but can be modified. At any
* point in time it contains some particular sequence of characters, but
* the length and content of the sequence can be changed through certain
* method calls.
* <p>
* String buffers are safe for use by multiple threads. The methods
* are synchronized where necessary so that all the operations on any
* particular instance behave as if they occur in some serial order
* that is consistent with the order of the method calls made by each of
* the individual threads involved.
* <p>
* The principal operations on a <code>StringBuffer</code> are the
* <code>append</code> and <code>insert</code> methods, which are
* overloaded so as to accept data of any type. Each effectively
* converts a given datum to a string and then appends or inserts the
* characters of that string to the string buffer. The
* <code>append</code> method always adds these characters at the end
* of the buffer; the <code>insert</code> method adds the characters at
* a specified point.
* <p>
* For example, if <code>z</code> refers to a string buffer object
* whose current contents are "<code>start</code>", then
* the method call <code>z.append("le")</code> would cause the string
* buffer to contain "<code>startle</code>", whereas
* <code>z.insert(4, "le")</code> would alter the string buffer to
* contain "<code>starlet</code>".
* <p>
* In general, if sb refers to an instance of a <code>StringBuffer</code>,
* then <code>sb.append(x)</code> has the same effect as
* <code>sb.insert(sb.length(), x)</code>.
* <p>
* Whenever an operation occurs involving a source sequence (such as
* appending or inserting from a source sequence) this class synchronizes
* only on the string buffer performing the operation, not on the source.
* <p>
* Every string buffer has a capacity. As long as the length of the
* character sequence contained in the string buffer does not exceed
* the capacity, it is not necessary to allocate a new internal
* buffer array. If the internal buffer overflows, it is
* automatically made larger.
*
* As of  release JDK 5, this class has been supplemented with an equivalent
* class designed for use by a single thread, {@link StringBuilder}.  The
* <tt>StringBuilder</tt> class should generally be used in preference to
* this one, as it supports all of the same operations but it is faster, as
* it performs no synchronization.
*
* @author    Arthur van Hoff
* @version     %I%, %G%
* @see     java.lang.StringBuilder
* @see     java.lang.String
* @since   JDK1.0
*/

StringBuilder类

/**
* A mutable sequence of characters.  This class provides an API compatible
* with <code>StringBuffer</code>, but with no guarantee of synchronization.
* This class is designed for use as a drop-in replacement for
* <code>StringBuffer</code> in places where the string buffer was being
* used by a single thread (as is generally the case).   Where possible,
* it is recommended that this class be used in preference to
* <code>StringBuffer</code> as it will be faster under most implementations.
*
* <p>The principal operations on a <code>StringBuilder</code> are the
* <code>append</code> and <code>insert</code> methods, which are
* overloaded so as to accept data of any type. Each effectively
* converts a given datum to a string and then appends or inserts the
* characters of that string to the string builder. The
* <code>append</code> method always adds these characters at the end
* of the builder; the <code>insert</code> method adds the characters at
* a specified point.
* <p>
* For example, if <code>z</code> refers to a string builder object
* whose current contents are "<code>start</code>", then
* the method call <code>z.append("le")</code> would cause the string
* builder to contain "<code>startle</code>", whereas
* <code>z.insert(4, "le")</code> would alter the string builder to
* contain "<code>starlet</code>".
* <p>
* In general, if sb refers to an instance of a <code>StringBuilder</code>,
* then <code>sb.append(x)</code> has the same effect as
* <code>sb.insert(sb.length(), x)</code>.
*
* Every string builder has a capacity. As long as the length of the
* character sequence contained in the string builder does not exceed
* the capacity, it is not necessary to allocate a new internal
* buffer. If the internal buffer overflows, it is automatically made larger.
*
* <p>Instances of <code>StringBuilder</code> are not safe for
* use by multiple threads. If such synchronization is required then it is
* recommended that {@link java.lang.StringBuffer} be used.
*
* @author    Michael McCloskey
* @version     %I%, %G%
* @see         java.lang.StringBuffer
* @see         java.lang.String
* @since    1.5
*/

2.创建数组时，用new创建，参数可以是变量。

3.从代码中的图可以看出这类问题，后边的字符可以看成前8个字符平移得到的，也就是要解决这个问题只需解决前8个字符即可，后面的只需i%8。

4.代码中有除法和求余操作，一定要注意除数不要为0，除数为0的情况另行处理。这个问题中，当loop=0时，求得numRows，另行处理。