1. import java.util.*;
   
2. 
   
3. /*
   
4. 有些没弄完，输出有重复的。
   
5. 
   
6. 引路深度，来确定运算层数。
   
7. 
   
8. Td//
   
9. */
   
10. 
    
11. public class LoopQDemo2{
    
12.         public static void main(String[] args){
    
13.        
    
14.                 //计算深度
    
15.                 int depth =5;
    
16.                
    
17.                 //存放圈
    
18.                 TreeSet<Integer> ts = new TreeSet<Integer>();
    
19.                
    
20.                
    
21.                 for(int i=10000;i<=99999;i++){
    
22.                         //每次都要清空
    
23.                         ts.clear();
    
24.                         //得到深度
    
25.                         int count = depth;
    
26.                        
    
27.                         int num = i;
    
28.                         //加入初始数
    
29.                         ts.add(i);
    
30.                        
    
31.                         while(count>0){
    
32.                                 //得到最大减最小的5位数
    
33.                                 num = getFiveSize(getMax(num)-getMin(num));
    
34.                                 if(i==num){
    
35.                                         //在运算深度内，若开始循环就打印圈
    
36.                                         sop(i+"------"+ts);
    
37.                                 }else{
    
38.                                         //否则继续，加入数
    
39.                                         count--;
    
40.                                         ts.add(num);
    
41.                                 }
    
42.                         }
    
43.                        
    
44.                 }
    
45.         }
    
46. 
    
47.         /*
    
48.                 得到补齐的5位数
    
49.         */
    
50.         static int getFiveSize(Integer x){
    
51.                 //变成字符数组起
    
52.                 char []cx = x.toString().toCharArray();
    
53.                 //不足5位
    
54.                 if(cx.length<5){
    
55.                         //后面加0
    
56.                         return (int)Math.pow(10,5-cx.length)*new Integer(new String(cx));
    
57.                 }
    
58.                 return new Integer(new String(cx));
    
59.         }
    
60.         //得到最小的数
    
61.         static int getMin(Integer x){
    
62.                 char []cx = x.toString().toCharArray();
    
63.                 //排序就好了， 你懂的
    
64.                 Arrays.sort(cx);
    
65.                 return new Integer(new String(cx));
    
66.         }
    
67.         //同上
    
68.         static int getMax(Integer x){
    
69.                 char []cx = x.toString().toCharArray();
    
70.                 Arrays.sort(cx);
    
71.                 for(int i = 0;i<cx.length/2;i++){
    
72.                         char tmp = cx[i];
    
73.                         cx[i]= cx[cx.length-1-i];
    
74.                         cx[cx.length-1-i] = tmp;
    
75.                 }
    
76.                 return new Integer(new String(cx));
    
77.         }
    
78.         //你懂的
    
79.         static void sop(Object o){
    
80.                 System.out.println(o);
    
81.         }
    
82.        
    
83.         /*
    
84.                
    
85.         static int isSame(Integer x1,Integer x2){
    
86.                 char []cx1 = x1.toString().toCharArray();
    
87.                 char []cx2 = x2.toString().toCharArray();
    
88.                 Arrays.sort(cx1);
    
89.                 Arrays.sort(cx2);
    
90.                 return new String(cx1).compareTo(new String(cx2));
    
91.         }
    
92.         */
    
93. }

复制代码

E:\Coder\cc>java LoopQDemo2
53955------[53955, 59994]
53955------[53955, 59994]
53955------[53955, 59994]
53955------[53955, 59994]
59994------[53955, 59994]
59994------[53955, 59994]
59994------[53955, 59994]
59994------[53955, 59994]
61974------[61974, 63954, 75933, 82962]
62964------[62964, 71973, 74943, 83952]
63954------[61974, 63954, 75933, 82962]
71973------[62964, 71973, 74943, 83952]
74943------[62964, 71973, 74943, 83952]
75933------[61974, 63954, 75933, 82962]
82962------[61974, 63954, 75933, 82962]
83952------[62964, 71973, 74943, 83952]

没有剔除重复的。。

将就看。。

没有完美。。

最终 我们都倒在了楼主的需求上....

参考参考吧。

1. 
   
2. import java.util.Arrays;
   
3. public class MyTest10 {
   
4.       public static void main(String args[])
   
5.       {
   
6.       
   
7.            int f=Sort(array(34256));
   
8.            int x=Sort(array(34256));
   
9.            for(int i=0;i<4;i++) {      
   
10.            x=Sort(array(x));
    
11.                System.out.print(x+" ");
    
12.            }
    
13.       }
    
14.       
    
15.       static int []array(int n)
    
16.       {
    
17.              int a[]=new int[5];
    
18.              int i=0;
    
19.              int m=n;
    
20.              while(i<5)
    
21.              {
    
22.                      a=m%10;
    
23.                      if(m%10==0)
    
24.                      a=0;
    
25.                      m/=10;
    
26.                            i++;
    
27.              }
    
28.              return a;
    
29.       }
    
30.       static int Sort(int a[]){
    
31.              Arrays.sort(a);
    
32.              String min="";
    
33.              for(int i=0;i<5;i++)
    
34.              {
    
35.                    min=min+String.valueOf(a);
    
36.              }
    
37.              int Min=Integer.parseInt(min);
    
38.              StringBuffer sb=new StringBuffer(min).reverse();
    
39.              String max=new StringBuffer(sb).toString();
    
40.              int Max=Integer.parseInt(max);
    
41.              int c=Max-Min;
    
42.              return c;
    
43.        }
    
44. }

复制代码

花了3小时，时间有点长了，刚开始不相信答案，查了下baidu觉得差不多了！
大家给点意见！！！

1. import java.io.FileWriter;
   
2. import java.io.IOException;
   
3. import java.util.*;
   
4. 
   
5. /*数字黑洞：
   
6. 有任意一个5位数，如：34256，
   
7. 把它的各位数字打乱，重新排列，就可得到一个最大的数：65432，还有一个最小的数23456。
   
8. 求这两个数字的差，得：41976，
   
9. 然后把这个数字再次重复上述过程（如果不足5位，则前边补0）。
   
10. 如此往复，数字会落入某个循环圈（称为数字黑洞）。
    
11. 比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。
    
12. 
    
13. 请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：
    
14. [82962, 75933, 63954, 61974]
    
15. 其中数字的先后顺序可以不考虑。*/
    
16. 
    
17. /*思路： 1.遍历5位数
    
18. *           2.对5位数进行排序，用StringBuilder的反转功能，Arrays的sort功能  获取最大值，最小值
    
19. *           3.计算差值，将最大值添加到list集合，原理是：list集合出现过这个最大值就会落入这两个最大值之间的循环圈；
    
20. *          4.用list集合存放最大值进行循环圈的判断，用set结合进行存放循环圈，由于第三部的算法，set集合去重复就简单了。
    
21. *注意：其实每个数都要落入一个循环圈，每个数落入的循环圈可以看你c盘下生产的"c:/digitalBlackHole.txt"文件，就是有点大，小心死机额！！！
    
22. */
    
23. public class DigitalBlaceHole {
    
24.         public static void main(String[] args) throws IOException
    
25.         {
    
26.                 ArrayList<String> al=new ArrayList<String>();//list排序后的每个最大数，
    
27.                 TreeSet<String> ts=new TreeSet<String>();//set集合存放不相同的循环圈
    
28.                 FileWriter fw=new FileWriter("c:/digitalBlackHole.txt");//存放每个数落入的循环圈
    
29.                 findDigital(al,fw,ts);//调用方法
    
30.                 for(String s:ts)//打印循环圈
    
31.                 {
    
32.                         System.out.println(s);
    
33.                         
    
34.                 }
    
35.         }
    
36.         public static void findDigital(ArrayList<String> al,FileWriter fw,TreeSet<String> ts) throws IOException
    
37.         {
    
38.                 for(int x=10000;x<100000;x++)//遍历
    
39.                 {
    
40.                         al.add("num:"+x);
    
41.                         dudge(x,al,fw,ts);//判断方法
    
42.                 }
    
43.         }
    
44.         private static void dudge(int num,ArrayList<String> al,FileWriter fw,TreeSet<String> ts) throws IOException {
    
45.                 while(true)
    
46.                 {
    
47.                         StringBuilder sb=new StringBuilder();//建立字符串缓冲区
    
48.                         char[] buf=(num+"").toCharArray();//获取数字对应的字符数组
    
49.                         Arrays.sort(buf);//排序数组
    
50.                         String min=new String(buf);//得到最小值
    
51.                         String max=sb.append(min).reverse().toString();//得到最大值
    
52.                         int mid=Integer.parseInt(max)-Integer.parseInt(min);//获取差值
    
53.                         if (al.contains(max)) {//判断集合是否有这个最大数存在
    
54.                                 int id=al.indexOf(max);//索引位置
    
55.                                 fw.write(al.subList(id, al.size()).toString());//获取子list集合字符串兵写入文件
    
56.                                 ts.add(al.subList(id, al.size()).toString());//获取子list集合字符串并存入set集合
    
57.                                 al.clear();//清空集合，进行下次判断
    
58.                                 break;
    
59.                         /*} else if (mid <= 0 || max.equals(min)) {//这个有点多余了，主要是每个数都要落入循环
    
60.                                 al.clear();
    
61.                                 break;*/
    
62.                         } else {
    
63.                                 al.add(max);//没落入循环继续判断
    
64.                                 //System.out.println(map);
    
65.                                 dudge(mid,al,fw, ts);//递归
    
66.                         }
    
67.                         break;//最后断开
    
68.                 }
    
69.         }
    
70. }
    

复制代码

运行结果：
[0]
[95553, 99954]
[96543, 97641, 98622, 97533]
[96642, 97731, 98532, 97443]
[97443, 96642, 97731, 98532]
[97533, 96543, 97641, 98622]
[97641, 98622, 97533, 96543]
[97731, 98532, 97443, 96642]
[98532, 97443, 96642, 97731]
[98622, 97533, 96543, 97641]
[99954, 95553]

吊炸天的题目

1. import java.util.TreeSet;
   
2. 
   
3. public class Test {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 // TODO Auto-generated method stub
   
7.                 TreeSet<String> blackHoleList = BlackHole(0, 100000);
   
8.                 // System.out.println(blackHoleList.size());
   
9.                 for (String tree : blackHoleList) {
   
10.                         System.out.println(tree);
    
11.                 }
    
12.         }
    
13. 
    
14.         /**
    
15.          * 输出一个储存数字黑洞TreeSet的ArrayList
    
16.          *
    
17.          * @param from
    
18.          * @param end
    
19.          * @return
    
20.          */
    
21.         public static TreeSet<String> BlackHole(int from, int end) {
    
22.                 TreeSet<String> blackHoleList = new TreeSet<String>();
    
23.                 // 建立一个角标从0-99999的boolean型数组
    
24.                 boolean[] numList = new boolean[end];
    
25.                 // 对数组进行遍历
    
26.                 for (int i = from; i < numList.length; i++) {
    
27.                         // 判断当前角标的数字是否已经在某个数字黑洞中
    
28.                         if (numList[i]) {
    
29.                                 continue;
    
30.                         }
    
31.                         // 建立储存数字黑洞的TreeSet
    
32.                         TreeSet<Integer> numTemp = new TreeSet<Integer>();
    
33.                         TreeSet<Integer> numTempArray = new TreeSet<Integer>();
    
34.                         // 从大小为i的数字开始 计算其重组后的数的最大值和最小值的差值
    
35.                         int reverseNum = i;
    
36. 
    
37.                         int count = 0;
    
38.                         // 通过while循环将遍历到的数及由其计算出的差值数存入一个TreeSet中
    
39.                         while (count < numTemp.size() * 2 + 1) {
    
40.                                 // 当再次向numTemp树中存入已有的数时返回false,于是进入if区域内，将该值存入numTempArray这个TreeSet中
    
41.                                 if (!numTemp.add(reverseNum)) {
    
42.                                         numTempArray.add(reverseNum);
    
43.                                 }
    
44.                                 // 记录该值已经遍历过
    
45.                                 numList[reverseNum] = true;
    
46.                                 // 获取其差值数
    
47.                                 reverseNum = cutNum(reverseNum);
    
48.                                 count++;
    
49.                         }
    
50. 
    
51.                         blackHoleList.add(numTempArray.toString());
    
52. 
    
53.                 }
    
54.                 return blackHoleList;
    
55.         }
    
56. 
    
57.         /**
    
58.          * 输入一个数输出重组后的数的最大值和最小值的差值
    
59.          *
    
60.          * @param num
    
61.          * @return
    
62.          */
    
63.         public static int cutNum(int num) {
    
64.                 String[] numStrList = Integer.toString(num).split("");
    
65.                 int[] numHash = new int[10];
    
66.                 for (int j = 1; j < numStrList.length; j++) {
    
67.                         numHash[Integer.parseInt(numStrList[j])]++;
    
68.                 }
    
69.                 int numBiggest, numSmallest;
    
70.                 StringBuilder numString = new StringBuilder();
    
71.                 for (int i = 0; i < numHash.length; i++) {
    
72.                         for (int k = 0; k < numHash[i]; k++) {
    
73.                                 numString.append(i);
    
74.                         }
    
75.                 }
    
76.                 numSmallest = Integer.parseInt(numString.toString());
    
77.                 numBiggest = Integer.parseInt(numString.reverse().toString());
    
78.                 return numBiggest - numSmallest;
    
79. 
    
80.         }
    
81. }

复制代码

[0]
[495]
[53955, 59994]
[6174]
[61974, 63954, 75933, 82962]
[62964, 71973, 74943, 83952]

小于5位数的结果在输出时做个判断就OK，懒得弄了。