1. class MaxSubstring  // 在Java中  有一个习惯 就是顾头不顾尾  
   
2. {
   
3.         public String maxString(String s1, String s2)
   
4.         {
   
5.                 for (int x=0; x<s2.length();x++ )
   
6.                 {
   
7.                         for (int y=0,z=s2.length()-x ;z<=s2.length() ; z++,y++)
   
8.                         {
   
9.                                 String temp=s2.substring(y,z);
   
10.                                 System.out.println(temp);
    
11.                                 System.out.println(x);
    
12.                                 System.out.println(y);
    
13.                                 System.out.println(z);//为了看程序是怎么取值的 我输出了他们
    
14.                                  if (s1.contains(temp))
    
15.                                 {
    
16.                                           return temp;
    
17.                                 }
    
18.                         }
    
19.                 }
    
20.                 return "";
    
21.   }
    
22. }
    
23. class  MaxSubstringTest
    
24. {
    
25.         public static void main(String[] args)
    
26.         {
    
27.                 MaxSubstring d= new MaxSubstring();
    
28.                 String str1="abdefhellqqqqoj";
    
29.                 String str2="cndhellqqqqo";                  
    
30.                 System.out.println(d.maxString(str1,str2));
    
31.        }
    
32. }
    

复制代码

就像上面说的我为了看他们的取值 我选择了输出他们
但是让我感到很奇怪的是
cndhellqqqqo
0
0
12
cndhellqqqq
1
0
11
ndhellqqqqo
1
1
12
cndhellqqq
2
0
10
ndhellqqqq
2
1
11
dhellqqqqo
2
2
12
cndhellqq
3
0
9
ndhellqqq
3
1
10
dhellqqqq
3
2
11
hellqqqqo
3
3
12
hellqqqqo
这个他们的输出结果 我想不明白 为什么是这么比较的...
我本以为会是
x=0
y=0 y=1 y=2 y=3 y=4...
然后
x=1
y=0 y=1 y=2 y=3 y=4...
然后
.
.
.

我们以为会是这样的循环 然后找到相同的
想请高手帮忙解析一下...

程序的逻辑是从两头不断的缩短字串的长度，并进行匹配。这样比先从一边缩短到头的效率要高。

首先在外层循环中x，是自增的。这样每次右侧开始的位置都要更向里，也就是z是不断减少的。
随着外层循环的继续，在内存循环中，y可以达到的最大值每次都在增加，产生了，从两头不断的缩短字串的长度，并进行匹配。的效果。

结果也就是
x = 0
y = 0
z = 12
x = 1
y = 0
z = 11
x = 1
y = 1
z = 12
x = 2
y = 0
z = 10
x = 2
y = 1
z = 11
x = 2
y = 2
z = 12
x = 3
y = 0
z = 9
x = 3
y = 1
z = 10
x = 3
y = 2
z = 11
x = 3
y = 3
z = 12
hellqqqqo

外循环是用来控制截取s2字符串的长度，内循环有2个变量，是用来控制截取s2字符串的位置。
例如x=0的时候，内循环开始y=0，z=s2.length()-x也就是12。那么也就是谁从s2字符串的0角标位到12角标位取出来（包含头不包含尾），用来和s1比较，所以打印
cndhellqqqqo
0
0
12
如果不是，内循环继续，y=1，z=13.愿意本来是准备取s2的1角标位到13角标位，结果发现z的值超过了s2的长度，所以内循环结束了，然后外循环继续，x++。那么x=1了
此时内循环重新开始，y重新定义为0，z=z=s2.length()-x，此时x已经为1了，所以z的初始值为11。然后我们就发现每次去s2的字符数少了一位。
现在你应该可以看明白了吧

赵倩倩 发表于 2012-6-16 21:40
程序的逻辑是从两头不断的缩短字串的长度，并进行匹配。这样比先从一边缩短到头的效率要高。

首先在外层循 ...

不是从两头开始减少的，只是外循环每次加1后，内循环截取的s2的长度会少一个，但是内循环每次仍旧是从最左边开始截取，然后首位一起向右移动，内循环每循环完一次，截取的长度都是相同的。如果从两头开始减少，就去不到s1和s2的最大公共子集了！

李盼 发表于 2012-6-16 21:53
不是从两头开始减少的，只是外循环每次加1后，内循环截取的s2的长度会少一个，但是内循环每次仍旧是从最左 ...

额，是这样滴，凌乱了

李盼 发表于 2012-6-16 21:49
外循环是用来控制截取s2字符串的长度，内循环有2个变量，是用来控制截取s2字符串的位置。
例如x=0的时候， ...

还真是这么回事 一直忽略了Z越界问题...
看来还是群众的眼睛是雪亮的...