package cn.it.interview;

public class JungleString {

        /**
         *用迭代的方法，判断是不是一个回文字符串，如”abdba”
         */
        public static void main(String[] args) {
               
                JungleString j=new JungleString();
               
                System.out.println(j.Jungle("abdbdbaca"));
        }

        private  boolean Jungle(String str) {
               
                while(str.length()>1){
               
                int strlength=str.length();
                char start=str.charAt(0);
                char end=str.charAt(strlength-1);
                if(start==end){
                        String str1=str.substring(1, strlength-1);
                        System.out.println(str1);
                        Jungle(str1);                        
                }else{                        
                        return false;                        
                }
                break;               
          }               
         return true;        
        }        
               
}

1. <div class="blockcode"><blockquote>package test;
   
2. 
   
3. public class JungleString {
   
4. 
   
5.         /**
   
6.          *用迭代的方法，判断是不是一个回文字符串，如”abdba”
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                
   
10.               
    
11.                
    
12.                 System.out.println(Jungle("abcdedcba"));
    
13.         }
    
14. 
    
15.         private static  boolean Jungle(String str) {
    
16.                
    
17.                 boolean flag = true;//出口判断标记，用这个标记来接收递归调用时的返回值
    
18.             while(str.length()>1){
    
19.                
    
20.                     int strlength=str.length();
    
21.                     char start=str.charAt(0);
    
22.                     char end=str.charAt(strlength-1);
    
23.                     if(start==end)
    
24.                     {
    
25.                             String str1=str.substring(1, strlength-1);
    
26.                         System.out.println(str1);
    
27.                         flag = Jungle(str1);  
    
28.                         //return flag;可在这里定义出口
    
29.                 }
    
30.                     else
    
31.                     {
    
32.                             return false;
    
33.                     }
    
34.                    
    
35.                     if(flag)//递归出口,在这里定义出口只是为了说明下问题，实际可以不需要在这里判断，直接在注释掉的位置加return。
    
36.                     {
    
37.                             return true;
    
38.                     }
    
39.                     else
    
40.                     {
    
41.                             return false;
    
42.                     }
    
43.             }
    
44.                         return flag;                    
    
45.         }        
    
46.                
    
47. }
    

复制代码

帮楼主的程序改了一下，不知道楼主是不是要实现这个功能。
楼主的递归出口定义错了。应该用方法的返回值做递归出口。
。。。看楼主的名字，不仔细看还以为和我重名了呢。。。呵呵

楼主你好，这样自己转貌似也太麻烦点了吧，字符串String中本身就封装了很多方法，我觉得没有必要一个一个字符判断。
private  boolean Jungle(String str) {
               
                return str.equals((new StringBuilder(str).reverse().toString()));//这样一句话搞定，哈哈
          }  
希望可以帮到楼主，嘿嘿

の放下执著 发表于 2013-7-27 17:11
楼主你好，这样自己转貌似也太麻烦点了吧，字符串String中本身就封装了很多方法，我觉得没有必要一个一个字 ...

晕！！！！似乎您理解错啦

王磊 发表于 2013-7-27 16:26
帮楼主的程序改了一下，不知道楼主是不是要实现这个功能。
楼主的递归出口定义错了。应该用方法的返回值做 ...

能否说下我那程序的具体执行过程哪部出错啦

HMHM汪磊 发表于 2013-7-27 17:17
能否说下我那程序的具体执行过程哪部出错啦

问题主要出在break上，因为按照楼主的程序，只要递归结束，就一定会执行break，而执行break跳出循环以后，相应的也一定会执行到结尾的return true，所以无论怎么样，返回的结果都是true。

我给你的代码是为了说明下问题，如果不定义标记的话，楼主可以去掉break，并在递归调用的时候，直接返回递归结果，如：return Jungle(str1)；

HMHM汪磊 发表于 2013-7-27 17:17
晕！！！！似乎您理解错啦

private  boolean Jungle(String str) {
               
                while(str.length()>1){
               
                int strlength=str.length();
                char start=str.charAt(0);
                char end=str.charAt(strlength-1);
                if(start==end){
                        String str1=str.substring(1, strlength-1);
                        System.out.println(str1);
                       return  Jungle(str1);               //改这句话         
                }else{                        
                        return false;                        
                }
             //   break;                //不要了
          }               
         return true;        
        }        

return  Jungle(str1);  //当我们判断回文时，当判断的两个对应的字符相同时，我们会继续递归判断；当不相同时，就没有必要再判断下去了，但这时我们要把判断的结果返回。我可能解释不够清楚，但道理确实是这样的。
最后：希望能帮到楼主，嘿嘿。