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(),&nbsp;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(),&nbsp;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，另行处理。