程序员编程艺术学习笔记(一)字符串左旋问题

程序员编程艺术原文出自大神:v_JULY_v 地址:http://blog.csdn.net/v_july_v/article/category/784066

c++实现.敬请膜拜。

由于之前忙于准备面试，但总觉得代码和算法分析实现力严重的不够扎实，了解自己所以心里没底。

最终决定沉下心来，从头把该实现的实现，从基础到升级版做到了然于心，自然心平气和，踏实自信。

原文C++实现，现将自己实现的java版本记录如下，不定期更新，自我监督，自我监督。

一,字符串左旋

题目描述：

定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部，如把字符串abcdef左旋转2位得到字符串cdefab。

请实现字符串左旋转的函数，要求对长度为n的字符串操作的时间复杂度为O(n)，空间复杂度为O(1)。

思路一、暴力移位法

初看此题，最先想到的笨方法可能就是一位一位移动。

完成一位的移动，再考虑x位的移动。

总体代码如下:

public class StrMove {
public static void main(String args[]){
String str="abcdefg";
int x=4;
//move1(str,x);
System.out.println(move1(str,x));
}

//暴力移位法
public static String move1(String str,int x){
char[] array=str.toCharArray();
while(x!=0){
char s=array[0];

if(x<array.length){

for(int i=0;i<array.length-1;i++){
array[i]=array[i+1];
}
array[array.length-1]=s;
x--;
}

else{
return "x is bigger than length";
}
}

String str2=new String(array);
return str2;
}

思路二、指针翻转法

咱们先来看个例子，如下：abc defghi，若要让abc移动至最后的过程可以是：abc defghi->def abcghi->def ghiabc

如此，我们可定义俩指针，p1指向ch[0]，p2指向ch[m]；

一下过程循环m次，交换p1和p2所指元素，然后p1++, p2++；。

第一步，交换abc 和def ，abc defghi->def abcghi
第二步，交换abc 和 ghi，def abcghi->def ghiabc

整个过程，看起来，就是abc 一步一步 向后移动

abc defghi
def abcghi
def ghi abc

//最后的 复杂度是O（m+n）

图解如下：

public static void main(String args[]){
String str="abcdefghi";
int x=3;

public static String move2(String str,int x){
char array[]=str.toCharArray();
if(array.length==0||x<0||x>array.length){
return "false";
}

for(int p1=0,p2=x;p1<array.length-x;p1++,p2++){

char tmp=array[p1];
array[p1]=array[p2];
array[p2]=tmp;
}

String str2=new String(array);
return str2;
}

由上述例子九个元素的序列abcdefghi，您已经看到，m=3时，p2恰好指到了数组最后一个元素，于是，上述思路没有问题。但如果上面例子中i 的后面还有元素列?

即，如果是要左旋十个元素的序列：abcdefghij，ok，下面，就举这个例子，对abcdefghij序列进行左旋转操作：

如果abcdef ghij要变成defghij abc：

abcdef ghij

1. def abc ghij

2. def ghi abc j //接下来，j 步步前移

3. def ghi ab jc

4. def ghi a j bc

5. def ghi j abc
下面，再针对上述过程，画个图清晰说明下，如下所示：







String str="abcdefghijx"；时，无法直接走到结尾:
返回结果为:defghiabcjx 需要处理尾巴

public static String move2(String str,int x){
char array[]=str.toCharArray();
if(array.length==0||x<0||x>array.length){
return "false";
}
int y=3;
int n=array.length;

for(int p1=0,p2=y;p1<array.length-y;p1++,p2++){
if(p2+y-1<array.length){
char tmp=array[p1];
array[p1]=array[p2];
array[p2]=tmp;
}else{

System.out.println("越界");
}
}

String str2=new String(array);
return str2;
}

ok，咱们来好好彻底总结一下此思路二：（就4点，请仔细阅读）：

1、首先让p1=ch[0]，p2=ch[m]，即让p1，p2相隔m的距离；

2、判断p2+m-1是否越界，如果没有越界转到3，否则转到4（abcdefgh这8个字母的字符串，以4左旋，那么初始时p2指向e，p2+4越界了，但事实上p2至p2+m-1是m个字符，可以再做一个交换）。

3、不断交换*p1与*p2，然后p1++，p2++，循环m次，然后转到2。

4、此时p2+m-1 已经越界，在此只需处理尾巴。过程如下：

4.1 通过n-p2得到p2与尾部之间元素个数r，即我们要前移的元素个数。

4.2 以下过程执行r次：

ch[p2]<->ch[p2-1]，ch[p2-1]<->ch[p2-2]，....，ch[p1+1]<->ch[p1]；p1++；p2++；

所以，之前最初的那个左旋转九个元素abcdefghi的思路在末尾会出现问题的（如果p2后面有元素就不能这么变，例如，如果是处理十个元素，abcdefghij 列?对的，就是这个意思），解决办法有两个：

方法一（即如上述思路总结所述）：

def ghi abc jk

当p1指向a，p2指向j时，由于p2+m越界，那么此时p1，p2不要变

这里p1之后（abcjk)就是尾巴，处理尾巴只需将j,k移到abc之前，得到最终序列



方法二：

def ghi abc jk

当p1指向a，p2指向j时，那么交换p1和p2，

此时为:

def ghi jbc ak

p1++，p2++,p1指向b，p2指向k，继续上面步骤得:

def ghi jkc ab

p1++，p2不动,p1指向c，p2指向b，p1和p2之间（cab)也就是尾巴，

那么处理尾巴（cab)需要循环左移一定次数（而后的具体操作步骤已在下述程序的注释中已详细给出）。

五:分块翻转

对于这个问题，咱们换一个角度，可以这么做：

将一个字符串分成两部分，X和Y两个部分，在字符串上定义反转的操作X^T，即把X的所有字符反转（如，X="abc"，那么X^T="cba"），那么我们可以得到下面的结论：(X^TY^T)^T=YX。显然我们这就可以转化为字符串的反转的问题了。

不是么?ok,就拿abcdef 这个例子来说，若要让def翻转到abc的前头，那么只要按下述3个步骤操作即可：

1、首先分为俩部分，X:abc，Y:def；

2、X->X^T，abc->cba， Y->Y^T，def->fed。

3、(X^TY^T)^T=YX，cbafed->defabc，即整个翻转。
我想，这下，你应该一目了然了。

其次，在《编程珠玑》上也有这样一个类似的问题，它的解法同本思路一致，如下图所示：

public static String move5(String str,int x){
//StringBuffer str2=new StringBuffer(str);
String tmp=str.substring(0, x);
String tmp2=str.substring(x, str.length());
StringBuffer str1=new StringBuffer(tmp);
str1.reverse();
System.out.println(str1);
StringBuffer str2=new StringBuffer(tmp2);
str2.reverse();
System.out.println(str2);
StringBuffer s=new StringBuffer();
s.append(str1);
s.append(str2);
s.reverse();
String a=new String(s);
return a;

}

public static String move6(String str,int x){
String tmp=str.substring(0, x);
String tmp2=str.substring(x, str.length());
tmp=reverse(tmp);
tmp2=reverse(tmp2);
//System.out.println(tmp);
//System.out.println(tmp2);
String str2=tmp+tmp2;
//System.out.println(str2);
String result=reverse(str2);
return  result;

}
public static String reverse(String str){
char[] array=str.toCharArray();
char tmp;
for(int i=0,j=array.length-1;i<j;i++,j--){
tmp=array[i];
array[i]=array[j];
array[j]=tmp;
}
String res=new String(array);

return res;

}