这个程序没有看明白，哪位大神给我加上注释呀，主要是 recursionSub不知道怎么运行的，有单步调试看着也很乱，帮帮忙
package com.itheima;
/**
* 第七题 编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符
例如：
原始字符串是"abc"，打印得到下列所有组合情况
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"
*/
import java.util.*;
public class Test11 {
         static int n,count = 0;
         static char[] array = { 'a', 'b', 'c' };
         static LinkedList <char[]> list = new LinkedList<char[]> ();//转化为集合
         static int[] indexs = new int[3];  
         static int len = array.length;

         public static void main(String[] args){
                                 getSub ();
                                
                 for ( char[] cs : list )     //遍历list
                 {       
                         //n++;
                        // if(n%3!=0)
                         
                    System.out.println(cs);
                        // else System.out.println(cs);
               }
             }

             private static LinkedList<char[]> getSub ()      //获取
             {
                 while (count <= len){
                     recursionSub (-1);
                     count++;
                 }
                 return list;
             }
             
             private static LinkedList <char[]> recursionSub ( int start )
             {
                             start++;
                            
                             if (start > count - 1)
                                     {
                                     return null;
                                     }
                             for ( indexs[start] = 0; indexs[start] < len; indexs[start]++ )
                                     {
                                             recursionSub (start);
                                             if (start == count - 1)
                                                     {
                                                             char[] temp = new char[count];
                                                             for ( int i = count - 1; i >= 0; i-- )
                                                                     {
                                                                             temp[start - i] = array[indexs[start - i]];
                                                                     }
                                                             boolean flag = true;
                                                             for ( int i = 0; i < temp.length; i++ )
                                                                     {
                                                                             for ( int j = i+1; j < temp.length; j++ )
                                                                                     {
                                                                                             if (temp[i] == temp[j])
                                                                                                     {
                                                                                                             flag = false;
                                                                                                             break;
                                                                                                     }
                                                                                     }
                                                                     }
                                                             if (flag)
                                                             {
                                                                     list.add (temp);
                                                             }
                                                     }       
                                     }
                             return list;
         }

}

亲，我也没看懂~~~同求啊……

这个函数好像是吧所有情况都列出来。

好麻烦啊

又学习了

表示木有看懂哦

幸好字符的长度是3，要是多点 我估计你的电脑内存都装不下你的代码

1. class AbcTest
   
2. {
   
3.         public static void main(String[] args){
   
4.                 math1();
   
5.         }
   
6.         public static void math1(){
   
7.                 String str = "abc";
   
8.                 char[] ch = str.toCharArray();//变成字符形式，
   
9.                
   
10.                 for (int i = 0; i<str.length(); i++)
    
11.                 {
    
12.                         String str1 = "";//所有可能字符的变量
    
13.                         str1 = str1 + ch[i];//取第一个字符
    
14.                         System.out.print(str1+" ");
    
15.                         for (int j = 0; j<str.length(); j++)
    
16.                         {
    
17.                                 //当第三层循环返回来的时候，字符串的长度是两个，需要给其重新赋值，保持第一个字符不变，其他两个在取值
    
18.                                 if (str1.length() == 2)
    
19.                                         str1 = "" + ch[i];
    
20. 
    
21.                                 if (!math(str1,ch[j]))
    
22.                                 {
    
23.                                         continue;
    
24.                                 }else{
    
25.                                         str1 = str1 + ch[j];
    
26.                                         System.out.print(str1+" ");
    
27.                                 }
    
28.                                 for (int k = 0; k<str.length(); k++)
    
29.                                 {
    
30.                                         if (!math(str1,ch[k]))
    
31.                                         {
    
32.                                                 continue;
    
33.                                         }else{
    
34.                                                 str1 = str1 + ch[k];
    
35.                                                 System.out.print(str1 + " ");
    
36.                                                 //保持前两个数不变，变换第三个字符
    
37.                                                 str1 = "" + ch[i] + ch[j];
    
38.                                         }
    
39.                                 }
    
40.                         }
    
41.                 }
    
42.         }
    
43. //判断这个字符串里面是否存在这个字符，存在返回false，不存在返回true
    
44.         public static boolean math(String str,char ch){
    
45.                 char[] ca = str.toCharArray();
    
46.                 boolean b = true;
    
47.                 for (int i = 0; i<ca.length; i++)
    
48.                 {
    
49.                         if (ca[i]==ch)
    
50.                                 b = false;
    
51.                 }
    
52.                 return b;
    
53.         }
    
54. }

复制代码

怎么会有这么复杂

我也碰到这题啊，赶脚有难度啊:L

package com.itheima;

import java.awt.List;
import java.util.ArrayList;

/**
* 第七题 编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符
例如：
原始字符串是"abc"，打印得到下列所有组合情况
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"

思路：1 每行字符个数都是递增 2 下一行的字符是建立在上一行的基础上得到的
即在将第一行字符串长度限定为1，第二行为2....，在第一行数据基础上{a,b,c}，创建第二行数据，遍历字符串中所字符，并与第一行数据组合。注意每行字符串长度限制
*/

public class Test12 {
        public static void main(String[] args){
                print("abcd");
        }
       
        //接收一个字符串返回全字符组合情况
        public static void print(String str){
                //将字符串转化为字符数组
                char[] ch = str.toCharArray();
                //建立一个存有{"a","b","c"}的集合list1
                ArrayList<String> list1 = new ArrayList<String>();
                for(int i = 0; i < ch.length; i++){
                        list1.add(ch[i]+"");
                }
               
                for(int i = 0; i < ch.length; i++){
                       
                        //取得每一行要输出的list集合
                        list1 = getList(list1, i+1,ch);
                       
                        //遍历输出集合
                        for(String s:list1){
                                System.out.print("\"" + s + "\" ");
                        }
                        System.out.println("");
                }
        }
       
        //取得每一行要输出的list集合
        public static ArrayList<String> getList(ArrayList<String> list,int len,char[] ch){
                //newList 用来装下一行要遍历的元素，list则代表上一行的元素集合
                ArrayList<String> newList  = new ArrayList<String>();
       
                //该循环用来取得上一行的元素
                for(String s:list){
                        String str = s;       
                               
                                for(int j = str.length();j < len ;j++){
                                        //遍历字符串中没个元素
                                        for(int i = 0; i < ch.length; i++){
                                                //字符不重复则将Str+ch[i]添加进集合，
                                                if(str.indexOf(ch[i]) == -1){
                                                        newList.add(str + ch[i]);
                                                }
                                        }
                                }
                               
                }
               
                return newList.size() == 0 ? list:newList;
        }

}

看着头疼，好难的样子~

:(好复杂

看题看的是思想

壹贰叁 发表于 2014-11-21 23:25
package com.itheima;

import java.awt.List;

"a" "b" "c"
"ab" "ac" "ba" "bc" "ca" "cb"
"abc" "acb" "bac" "bca" "cab" "cba"
运行结果不对啊

这个字符串的长度也不一定就是3啊，是任意长度的吧？

看不太懂

0小菜鸟0 发表于 2014-8-17 18:05

你这只能取三个字符的