leetcode-java 反转字符串

反转字符串

反转字符串 I

题目描述：

leetcode 344.反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：

输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

问题分析：

利用一个tmp变量和对称原则进行数据交换即可

代码展示(已验证)：

//leetcode 344.反转字符串
class Solution {
    public void reverseString(char[] s) {
        char tmp;
        for(int i=0;i<s.length/2;i++)
        {
            tmp = s[i];
            s[i] = s[s.length-1-i];
            s[s.length-1-i] = tmp;
        }
    }
}

反转字符串 II

题目描述：

leetcode 541.反转字符串 II
	给定一个字符串和一个整数 k，你需要对从字符串开头算起的每个 2k 个字符的前k个字符进行反转。
	如果剩余少于 k 个字符，则将剩余的所有全部反转。如果有小于 2k 但大于或等于 k 个字符，则反转前 k 个字符
	并将剩余的字符保持原样。
	
	示例:
	
	输入: s = "abcdefg", k = 2
	输出: "bacdfeg"
	要求:
	
	该字符串只包含小写的英文字母。
	给定字符串的长度和 k 在[1, 10000]范围内。

问题分析：

这些要交换的数据有规律性的交换数据(相差2k)，在一个层级的循环中完成k个数据的交换，然后return
最外面循环的次数等同于s.length中包含几个2k
内部数据的交换 依靠 while 循环来解决

代码展示(已验证)：

class Solution {
    public String reverseStr(String s, int k) {
        char[] a = s.toCharArray();
        for (int start = 0; start < a.length; start += 2 * k) {	//按照 2k 往上加
            int i = start, j = Math.min(start + k - 1, a.length - 1);// 判断是否越界
            while (i < j) {	//交换数据，如果k=1,则因为 i<j 的原因数据不进行交换
                char tmp = a[i];
                a[i++] = a[j];
                a[j--] = tmp;
            }
        }
        return new String(a);
        
 // 写出这样的代码，好垃圾。。。
//         int m=1;
//         StringBuffer str = new StringBuffer();

//         if(k==1)
//             return s;
//         if(s.length()<=k)
//         {
//             return new StringBuilder(s).reverse().toString();
//         }
//         else if(s.length()>k && s.length()<=2*k)
//         {
//             for(int i=k-1;i>=0;i--)
//             {
//                 str.append(s.charAt(i));
//             }
//             for(int i=k;i<s.length();i++)
//                 str.append(s.charAt(i));
//             return str.toString();
//         }
//         else
//         {
//             for(int i=0;i<s.length()/(2*k);i++)
//             {
//                 for(int j=(k-1)+(m-1)*k;j>=(m-1)*2*k;j--)
//                 {
//                     str.append(s.charAt(j));
//                 }
//                 for(int j=k+(m-1)*k;j<2*k+(m-1)*k;j++)
//                     str.append(s.charAt(j));
//                 m++;

//             }
//             m-=1;
//             if(s.length()-m*2*k<=k)
//             {
//                 for(int i=s.length()-1;i>=m*2*k;i++)
//                     str.append(s.charAt(i));
//             }
//             else if(s.length()-m*2*k>k && s.length()-2*m*k<2*k)
//             {
//                 for(int i=m*2*k+k-1;i>=m*2*k;i--)
//                 {
//                     str.append(s.charAt(i));
//                 }
//                 for(int i=m*2*k+k;i<s.length();i++)
//                     str.append(s.charAt(i));

//             }
//         }
//         return str.toString();
    }
}

泡泡：

	反转字符串，反转数组等牵扯到顺序的问题，核心大多数都在数据的交换上，如何更好的交换数据以及能够交换
	数据，这个挺重要的
	还有就是可以想一下这两个题与回文题目的相似之处。