as604049322 发表于 2015-6-1 13:29
combinations("abcd",2);第2个参数，想取几个就取几个

不错，但这个程序考虑了顺序的变化，而且如果字符串较大的话，取的数也大一点，会有点问题，例如：combinations("123456789zhong",9) 。这题目要求不需要考虑顺序变化的情况，比喻12和21就属于同一种情况

半月 发表于 2015-6-1 14:05
public class Test2 {
        public static void main(String[] args) {
                String str = "abcde";

这个程序可以，用递归做的，结果和题目要求一样，学习了，感谢

半月 发表于 2015-6-1 14:05
public class Test2 {
        public static void main(String[] args) {
                String str = "abcde";

这个程序可以，用递归做的，结果和题目要求一样，学习了，感谢

怎么回复重复了，其实今天上午我自己又做了一下，用了两种方法做的，第一种和楼上的一样都是用递归做的，第二种用的是数组加循环做的。总算自己也做出来了，非常感谢大家的参与和帮忙

分享一下上午做出来的两种方法：（时间太快，没写注释）
1.用递归做的：public class StringSort3 {
        public static int count=0;
        public static void main(String[] args){
                String str="123456789";
                sort("",str,7);
                System.out.println(count);
        }
        public static void sort(String strPre,String str,int value){
                if(value==0)
                        return;
                String temp="";
                String strL="";
                for(int x=0;x<=str.length()-value;x++){
                        temp=strPre;
                        strPre=strPre+str.substring(x,x+1);
                        if(value==1){
                                System.out.println(strPre);
                                count++;
                        }
                        strL=str.substring(x+1,str.length());
                        value-=1;
                        sort(strPre,strL,value);
                        value+=1;
                        strPre=temp;
                }
        }
}

第二种方法：数组加循环

1. public class StringSort2 {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static int count=0;
   
7.         public static void main(String[] args) {
   
8.                 // TODO Auto-generated method stub
   
9.                 String str="0123456789";
   
10.                 sort(str,4);
    
11.                 System.out.println(count);
    
12.         }
    
13.        
    
14.         public static void sort(String str,int value){
    
15.                 int pos1=0,pos2=0;
    
16.                 char[] ch= str.toCharArray();
    
17.                 char[] temp=new char[value];
    
18.                 for(int x=0;x<temp.length;x++)
    
19.                         temp[x]=ch[x];
    
20.                 System.out.println(String.valueOf(temp));
    
21.                 count++;
    
22.                 for(int i=value;i<=ch.length;i++){
    
23.                         if(i<ch.length){
    
24.                                 temp[value-1]=ch[i];
    
25.                                 System.out.println(String.valueOf(temp));
    
26.                                 count++;
    
27.                         }
    
28.                         else
    
29.                                 i=ch.length-1;
    
30.                         if(i==ch.length-1){
    
31.                                 for(int a=1;a<=value;a++){
    
32.                                         if(temp[value-a]!=ch[ch.length-a]){
    
33.                                                 pos1=a;
    
34.                                                 break;
    
35.                                         }
    
36.                                 }
    
37.                                 for(int b=0;b<ch.length;b++){
    
38.                                         if(temp[value-pos1]==ch[b]){
    
39.                                                 pos2=b;
    
40.                                                 break;
    
41.                                         }
    
42.                                 }
    
43.                                 for(int a=pos1,b=pos2;a>0;a--,b++){
    
44.                                         temp[value-a]=ch[b+1];
    
45.                                 }
    
46.                                 System.out.println(String.valueOf(temp));
    
47.                                 count++;
    
48.                                 if(temp[0]==ch[ch.length-value])
    
49.                                         return;
    
50.                                 i=pos1+pos2;
    
51.                         }
    
52.                 }
    
53.         }

复制代码

探索者 发表于 2015-6-1 15:56
不错，但这个程序考虑了顺序的变化，而且如果字符串较大的话，取的数也大一点，会有点问题，例如：combin ...

早知道是不用考虑顺序的我就不用这么蛋疼了。。。

1. package cn.wangzhe;
   
2. 
   
3. import java.util.LinkedList;
   
4. 
   
5. 
   
6. /*
   
7. 在求一个字符串中所有字符的组合的时候，针对一个字符，有两种情况，假设在长度为n的字符串中选择长度为m的组合字符串，
   
8. 
   
9. 第一是选择长度为n的字符串中的第一个字符，那么要在其余的长度n-1的字符串中选择m-1个字符
   
10. 
    
11. 第二是不选择长度为n的字符串中的第一个字符，那么要在其余的长度n-1的字符串中选择m个字符
    
12. 
    
13. 递归结束的条件就是，当m为0，即从字符串中不再选出字符的时候，这个时候已经找到了m个字符的组合，输出即可。
    
14. 还有一个条件是，当输入的字符串是空，自然是不能从中选出任何字符的。
    
15. */
    
16. public class CombinationStr{
    
17.         public static void main(String[] args) {
    
18. //                combination("abcd");
    
19.                 combination("abcde",3);
    
20.         }
    
21. 
    
22.     public static void combination(String str,int len){
    
23.             combination("abcde",len,new StringBuilder());
    
24.     }
    
25.     private static void combination(String str,int m,StringBuilder result){//c(n,m)
    
26.         if(m==0){
    
27.                 System.out.print(result+" ");
    
28.             return ;
    
29.         }
    
30.         if(str.length()>0){
    
31.             result.append(str.charAt(0));
    
32.             combination(str.substring(1),m-1,result);
    
33.             result.deleteCharAt(result.length()-1);
    
34.             combination(str.substring(1),m,result);
    
35.         }
    
36.     }
    
37. 
    
38. 
    
39. }
    

复制代码

难度系数大，思考思考！！！

as604049322 发表于 2015-6-1 16:30
早知道是不用考虑顺序的我就不用这么蛋疼了。。。

感觉考虑顺序比较麻烦，不过做出了不用考虑顺序的程序，再做个可以进行全排的，结合起来就和你那个的效果差不多了