改进一个求组合数的算法！

刚写了个求数字组合的程序，
比如
Please input the number:
3
     1     2     3
     1     3     2
     2     1     3
     2     3     1
     3     1     2
     3     2     1
TotalCount is :6
Please input the number:
4
     1     2     3     4
     1     2     4     3
     1     3     2     4
     1     3     4     2
     1     4     2     3
     1     4     3     2
     2     1     3     4
     2     1     4     3
     2     3     1     4
     2     3     4     1
     2     4     1     3
     2     4     3     1
     3     1     2     4
     3     1     4     2
     3     2     1     4
     3     2     4     1
     3     4     1     2
     3     4     2     1
     4     1     2     3
     4     1     3     2
     4     2     1     3
     4     2     3     1
     4     3     1     2
     4     3     2     1
TotalCount is :24
即每一行任意数字都不相等，感觉写得较勉强，算法不太好，用递归写的。请各位给个比较好的算法？下面是我的代码，用java写的。import java.util.Scanner;public class Myarrange { public class Arrint {
int num;// 需进行排列组合的元素。 boolean bool;// 当前元素是否被使用。 Arrint(int k) {
num = k;
bool = false;
}
} public class workItem {
int num; // 当前存储的数字 boolean bool; // 当前数据是否是有效的 workItem(int k) {
num = k;
bool = false;
}
} int TotalCount = 0;// 组合的总数 boolean isFirstline = true; Arrint[] arrint;// 需要进行组合的数据，初始化在构造函数中完成。 int count = 0;// 计数器，用于处理第一行数据的处理，因为第一行数据的处理规则和其它行有所不同。 workItem[] work; public Myarrange(int k) {
arrint = new Arrint[k + 1];
work = new workItem[k + 1];
for (int i = 0; i < arrint.length; i++) {
arrint[i] = new Arrint(i);
work[i] = new workItem(0);
}
} boolean check(Arrint[] arr) {
for (int i = 1; i <= arr.length - 1; i++) {
if (arr[i].bool == false) {
return false;
}
}
return true;
} int minCanused() {
for (int i = 1; i < arrint.length; i++) {
if (arrint[i].bool == false)
return arrint[i].num;
}
return 0;
} int maxCanused() {
for (int i = arrint.length - 1; i > 0; i--) {
if (arrint[i].bool == false) {
return arrint[i].num;
}
}
return 0;
} int minNotlessthanCanused(int k) {
for (int i = 1; i < arrint.length; i++) {
if (arrint[i].bool == false && arrint[i].num > k)
return arrint[i].num;
}
return 0;
} void comb(int level, int k) {
int temp;
while (true) {
if (isFirstline == true) {
count++;
work[level].num = minCanused();
work[level].bool = true;
arrint[work[level].num].bool = true;
} else if ((temp = minNotlessthanCanused(work[level].num)) != 0
&& work[level].bool == true) {
arrint[temp].bool = true;
arrint[work[level].num].bool = false;
work[level].num = temp;
work[level].bool = true;
} else {
work[level].num = minCanused();
work[level].bool = true;
arrint[work[level].num].bool = true;
}
if (check(arrint)) {
TotalCount++;
print(work);
} else {
comb(level + 1, k);
}
if (level == k) {// 当到达一行最后一个元素时，回退至上层
arrint[work[level].num].bool = false;// 将当前层的工作数组中的元素状态置成未使用状态
work[level].bool = false; // 将当前工作数组中的数据元素置为无效数据
if (count == k)
isFirstline = false;// 如果第一行已经输出完毕，将状态标置置为false;
break;
}
if (work[level].num < maxCanused()) {// 如果当前元素比可用数字中的最大数字小的话那么在可用数字中重新挑选一个作为当前数字。
continue;
} else {
arrint[work[level].num].bool = false;
work[level].bool = false;
break;
}
}
} void print(workItem[] a) {
for (int i = 1; i < a.length; i++) {
System.out.printf("%6d", a[i].num);
}
System.out.println();
} public static void main(String[] args) {
System.out.println("Please input the number:");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
Myarrange Myarr = new Myarrange(i);
// Myarr.printFirstline(i);
Myarr.comb(1, i);
System.out.println("TotalCount is :" + Myarr.TotalCount);
}}

解决方案 »

  1.   

    这是我的做法：import java.util.*;
    public class test{
      ArrayList list = new ArrayList();
      test(String in){
        for(int i=0;i<in.length();i++)
          list.add(in.substring(i,i+1));
        printList(0,list);
      }
      ArrayList replaceStr(ArrayList s,int c1,int c2){
        s.add(c1,s.get(c2));
        s.remove(c2+1);
        return s;
      }
      void printList(int start,ArrayList temparr){
        if(start==list.size()-1)
          for(int i=0;i<temparr.size();i++)
            System.out.print(temparr.get(i)+(i==temparr.size()-1?" ":""));
        else
          for(int i=start;i<list.size();i++)
            printList(start+1,replaceStr(new ArrayList(temparr),start,i));
      }
      public static void main(String args[]){
        if(args.length==0)
          new test("2468");
        else
          new test(args[0]);
      }
    }
      

  2.   

    唉，你是第一日编程么？纠缠在这些小问题上这样一改，不就可以了？
    import java.util.*;
    public class test{
      ArrayList list = new ArrayList();
      test(String in){
        int temp = Integer.parseInt(in);
        for(int i=0;i<temp;i++)
          list.add(String.valueOf(i+1));
        printList(0,list);
      }
      ArrayList replaceStr(ArrayList s,int c1,int c2){
        s.add(c1,s.get(c2));
        s.remove(c2+1);
        return s;
      }
      void printList(int start,ArrayList temparr){
        if(start==list.size()-1)
          for(int i=0;i<temparr.size();i++)
            System.out.print(temparr.get(i)+(i==temparr.size()-1?" ":","));
        else
          for(int i=start;i<list.size();i++)
            printList(start+1,replaceStr(new ArrayList(temparr),start,i));
      }
      public static void main(String args[]){
          new test(args[0]);
      }
    }
      

  3.   

    其实，这个算法不用容器也是可以的，当初只是为了方便调试，后来也懒得改，如下：public class test{
      String[] list;
      StringBuffer sb = new StringBuffer();
      test(String in){
        int temp = Integer.parseInt(in);
        list = new String[temp];
        for(int i=0;i<temp;i++)
          list[i] = String.valueOf(i+1);
        printList(0,list);
        System.out.println(sb);
      }
      String[] replaceStr(String[] s,int c1,int c2){
        int temp = c1;
        c1 = c2;
        c2 = temp;
        return s;
      }
      void printList(int start,String[] temparr){
        if(start==list.length-1)
          for(int i=0;i<temparr.length;i++)
            sb.append(temparr[i]+(i==temparr.length-1?" ":""));
        else
          for(int i=start;i<list.length;i++)
            printList(start+1,replaceStr(temparr.clone(),start,i));
      }
      public static void main(String args[]){
        new test(args[0]);
      }
    }改进了一下，在输入6的情况下
    阁下的算法大概要2000毫秒
    我原来的算法大概要700毫秒
    用stringBuffer优化一下之后，大概要用70毫秒
    再改用数组实现后大概要用60毫秒
      

  4.   

    搞错，应该是这个才对
    public class test{
      String[] list;
      StringBuffer sb = new StringBuffer();
      test(String in){
        int temp = Integer.parseInt(in);
        list = new String[temp];
        for(int i=0;i<temp;i++)
          list[i] = String.valueOf(i+1);
        printList(0,list);
        System.out.println(sb);
      }
      String[] replaceStr(String[] s,int c1,int c2){
        String temp = s[c1];
        s[c1] = s[c2];
        s[c2] = temp;
        return s;
      }
      void printList(int start,String[] temparr){
        if(start==list.length-1)
          for(int i=0;i<temparr.length;i++)
            sb.append(temparr[i]+(i==temparr.length-1?" ":""));
        else
          for(int i=start;i<list.length;i++)
            printList(start+1,replaceStr(temparr.clone(),start,i));
      }
      public static void main(String args[]){
        long t1 = System.currentTimeMillis();
        new test(args[0]);
        System.out.println(System.currentTimeMillis()-t1);
      }
    }但是，用了stringbuffer之后，需要大量内存，所以不可行再改回使用print输出
    public class test{
      String[] list;
      test(String in){
        int temp = Integer.parseInt(in);
        list = new String[temp];
        for(int i=0;i<temp;i++)
          list[i] = String.valueOf(i+1);
        printList(0,list);
      }
      String[] replaceStr(String[] s,int c1,int c2){
        String temp = s[c1];
        s[c1] = s[c2];
        s[c2] = temp;
        return s;
      }
      void printList(int start,String[] temparr){
        if(start==list.length-1)
          for(int i=0;i<temparr.length;i++)
            System.out.print(temparr[i]+(i==temparr.length-1?" ":""));
        else
          for(int i=start;i<list.length;i++)
            printList(start+1,replaceStr(temparr.clone(),start,i));
      }
      public static void main(String args[]){
        new test(args[0]);
      }
    }
    用时400毫秒，不受内存的限制
      

  5.   

    但是分段用StringBuffer，基本上是不受内存限制，而且可以节省一半以上的时间
      

  6.   

    不知兄台是如何测试的，我在Eclipse下面对我的程序和你的两个程序均分别进行了测试，在输入6的情况下时间均在2000毫秒左右，你的程序测试情况只是略好于我的，反复多次测试，都没有哪个用时少于1800毫秒的。
      

  7.   

    C:\java>java test 6
    123456 123465 123546 123564 123654 123645 124356 124365 124536 124563 124653 124
    635 125436 125463 125346 125364 125634 125643 126453 126435 126543 126534 126354
     126345 132456 132465 132546 132564 132654 132645 134256 134265 134526 134562 13
    4652 134625 135426 135462 135246 135264 135624 135642 136452 136425 136542 13652
    4 136254 136245 143256 143265 143526 143562 143652 143625 142356 142365 142536 1
    42563 142653 142635 145236 145263 145326 145362 145632 145623 146253 146235 1465
    23 146532 146352 146325 153426 153462 153246 153264 153624 153642 154326 154362
    154236 154263 154623 154632 152436 152463 152346 152364 152634 152643 156423 156
    432 156243 156234 156324 156342 163452 163425 163542 163524 163254 163245 164352
     164325 164532 164523 164253 164235 165432 165423 165342 165324 165234 165243 16
    2453 162435 162543 162534 162354 162345 213456 213465 213546 213564 213654 21364
    5 214356 214365 214536 214563 214653 214635 215436 215463 215346 215364 215634 2
    15643 216453 216435 216543 216534 216354 216345 231456 231465 231546 231564 2316
    54 231645 234156 234165 234516 234561 234651 234615 235416 235461 235146 235164
    235614 235641 236451 236415 236541 236514 236154 236145 243156 243165 243516 243
    561 243651 243615 241356 241365 241536 241563 241653 241635 245136 245163 245316
     245361 245631 245613 246153 246135 246513 246531 246351 246315 253416 253461 25
    3146 253164 253614 253641 254316 254361 254136 254163 254613 254631 251436 25146
    3 251346 251364 251634 251643 256413 256431 256143 256134 256314 256341 263451 2
    63415 263541 263514 263154 263145 264351 264315 264531 264513 264153 264135 2654
    31 265413 265341 265314 265134 265143 261453 261435 261543 261534 261354 261345
    321456 321465 321546 321564 321654 321645 324156 324165 324516 324561 324651 324
    615 325416 325461 325146 325164 325614 325641 326451 326415 326541 326514 326154
     326145 312456 312465 312546 312564 312654 312645 314256 314265 314526 314562 31
    4652 314625 315426 315462 315246 315264 315624 315642 316452 316425 316542 31652
    4 316254 316245 341256 341265 341526 341562 341652 341625 342156 342165 342516 3
    42561 342651 342615 345216 345261 345126 345162 345612 345621 346251 346215 3465
    21 346512 346152 346125 351426 351462 351246 351264 351624 351642 354126 354162
    354216 354261 354621 354612 352416 352461 352146 352164 352614 352641 356421 356
    412 356241 356214 356124 356142 361452 361425 361542 361524 361254 361245 364152
     364125 364512 364521 364251 364215 365412 365421 365142 365124 365214 365241 36
    2451 362415 362541 362514 362154 362145 423156 423165 423516 423561 423651 42361
    5 421356 421365 421536 421563 421653 421635 425136 425163 425316 425361 425631 4
    25613 426153 426135 426513 426531 426351 426315 432156 432165 432516 432561 4326
    51 432615 431256 431265 431526 431562 431652 431625 435126 435162 435216 435261
    435621 435612 436152 436125 436512 436521 436251 436215 413256 413265 413526 413
    562 413652 413625 412356 412365 412536 412563 412653 412635 415236 415263 415326
     415362 415632 415623 416253 416235 416523 416532 416352 416325 453126 453162 45
    3216 453261 453621 453612 451326 451362 451236 451263 451623 451632 452136 45216
    3 452316 452361 452631 452613 456123 456132 456213 456231 456321 456312 463152 4
    63125 463512 463521 463251 463215 461352 461325 461532 461523 461253 461235 4651
    32 465123 465312 465321 465231 465213 462153 462135 462513 462531 462351 462315
    523416 523461 523146 523164 523614 523641 524316 524361 524136 524163 524613 524
    631 521436 521463 521346 521364 521634 521643 526413 526431 526143 526134 526314
     526341 532416 532461 532146 532164 532614 532641 534216 534261 534126 534162 53
    4612 534621 531426 531462 531246 531264 531624 531642 536412 536421 536142 53612
    4 536214 536241 543216 543261 543126 543162 543612 543621 542316 542361 542136 5
    42163 542613 542631 541236 541263 541326 541362 541632 541623 546213 546231 5461
    23 546132 546312 546321 513426 513462 513246 513264 513624 513642 514326 514362
    514236 514263 514623 514632 512436 512463 512346 512364 512634 512643 516423 516
    432 516243 516234 516324 516342 563412 563421 563142 563124 563214 563241 564312
     564321 564132 564123 564213 564231 561432 561423 561342 561324 561234 561243 56
    2413 562431 562143 562134 562314 562341 623451 623415 623541 623514 623154 62314
    5 624351 624315 624531 624513 624153 624135 625431 625413 625341 625314 625134 6
    25143 621453 621435 621543 621534 621354 621345 632451 632415 632541 632514 6321
    54 632145 634251 634215 634521 634512 634152 634125 635421 635412 635241 635214
    635124 635142 631452 631425 631542 631524 631254 631245 643251 643215 643521 643
    512 643152 643125 642351 642315 642531 642513 642153 642135 645231 645213 645321
     645312 645132 645123 641253 641235 641523 641532 641352 641325 653421 653412 65
    3241 653214 653124 653142 654321 654312 654231 654213 654123 654132 652431 65241
    3 652341 652314 652134 652143 651423 651432 651243 651234 651324 651342 613452 6
    13425 613542 613524 613254 613245 614352 614325 614532 614523 614253 614235 6154
    32 615423 615342 615324 615234 615243 612453 612435 612543 612534 612354 612345
    330   <<<就这个 System.currentTimeMillis()-t1
      

  8.   

    您的：
    ...
         6     4     5     2     3     1
         6     4     5     3     1     2
         6     4     5     3     2     1
         6     5     1     2     3     4
         6     5     1     2     4     3
         6     5     1     3     2     4
         6     5     1     3     4     2
         6     5     1     4     2     3
         6     5     1     4     3     2
         6     5     2     1     3     4
         6     5     2     1     4     3
         6     5     2     3     1     4
         6     5     2     3     4     1
         6     5     2     4     1     3
         6     5     2     4     3     1
         6     5     3     1     2     4
         6     5     3     1     4     2
         6     5     3     2     1     4
         6     5     3     2     4     1
         6     5     3     4     1     2
         6     5     3     4     2     1
         6     5     4     1     2     3
         6     5     4     1     3     2
         6     5     4     2     1     3
         6     5     4     2     3     1
         6     5     4     3     1     2
         6     5     4     3     2     1
    921  <<<这里
    TotalCount is :720呵呵，大家互相学习嘛
    但是CSDN里的高手一般都不肯出招，在CSDN里学不了什么东西
      

  9.   

    可能是我使用eclipse的原因吧？？导致测试结果不准确？
      

  10.   

    这回是优化了输出效率，还有空间复杂度
    public class test{
      String[] list;
      StringBuffer sb;
      test(String in){
        int temp = Integer.parseInt(in);
        list = new String[temp];
        for(int i=0;i<temp;i++)
          list[i] = String.valueOf(i+1);
        printList(0,list);
      }
      String[] replaceStr(String[] s,int c1,int c2){
        String temp = s[c1];
        s[c1] = s[c2];
        s[c2] = temp;
        return s;
      }
      void printList(int start,String[] temparr){
        if(start==list.length-1){
          sb = new StringBuffer();
          for(int i=0;i<temparr.length;i++)
            sb.append(temparr[i]);
          sb.append(" ");
          System.out.print(sb);
        }else{
          for(int i=start;i<list.length;i++){
            replaceStr(temparr,start,i);
            printList(start+1,temparr);
            replaceStr(temparr,i,start);
          }
        }
      }
      public static void main(String args[]){
        long t1 = System.currentTimeMillis();
        new test(args[0]);
        System.out.println(System.currentTimeMillis()-t1);
      }
    }514236 514263 514623 514632 512436 512463 512346 512364 512634 512643 516423 516
    432 516243 516234 516324 516342 563412 563421 563142 563124 563214 563241 564312
     564321 564132 564123 564213 564231 561432 561423 561342 561324 561234 561243 56
    2413 562431 562143 562134 562314 562341 623451 623415 623541 623514 623154 62314
    5 624351 624315 624531 624513 624153 624135 625431 625413 625341 625314 625134 6
    25143 621453 621435 621543 621534 621354 621345 632451 632415 632541 632514 6321
    54 632145 634251 634215 634521 634512 634152 634125 635421 635412 635241 635214
    635124 635142 631452 631425 631542 631524 631254 631245 643251 643215 643521 643
    512 643152 643125 642351 642315 642531 642513 642153 642135 645231 645213 645321
     645312 645132 645123 641253 641235 641523 641532 641352 641325 653421 653412 65
    3241 653214 653124 653142 654321 654312 654231 654213 654123 654132 652431 65241
    3 652341 652314 652134 652143 651423 651432 651243 651234 651324 651342 613452 6
    13425 613542 613524 613254 613245 614352 614325 614532 614523 614253 614235 6154
    32 615423 615342 615324 615234 615243 612453 612435 612543 612534 612354 612345
    100  <<降到100了排除输出部分（不输出内容），仅从算法方面看，输入10时
    原先使用容器的要7200毫秒左右
    改用数组后，要4800毫秒左右
    在优化空间复杂度之后，只用了550毫秒
      

  11.   

    从n个数中取出m个数的排列总数如下（n个元素的序号分别为0、1、2、...、n-1）
    package cxz.math;import java.util.ArrayList;public class Arrange {
      private static ArrayList<Integer> v = new ArrayList<Integer>();
      static int n = 5, m = 3;  public static void main(String[] args) {
        for (int i = 0; i < n; i++)
          sign[i] = false;
        f(n, m);
      }  private static boolean[] sign = new boolean[n];
      static int count = 0;
      static int num = 0;  public static void f(int n, int m) {
        if (count == m) {
          show();
          return;
        }
        for (int i = 0; i < n; i++) {
          if (!sign[i]) {
            v.add(i);
            sign[i] = true;
            count++;
            f(n, m);
            count--;
            sign[i] = false;
            v.remove(v.size() - 1);
          }
        }
      }  public static void show() {
        System.out.print((num++) + ":");
        for (int i = 0; i < v.size(); i++)
          System.out.print(v.get(i) + " ");
        System.out.println();
      }
    }
    ///////////
    0:0 1 2 
    1:0 1 3 
    2:0 1 4 
    3:0 2 1 
    4:0 2 3 
    5:0 2 4 
    6:0 3 1 
    7:0 3 2 
    8:0 3 4 
    9:0 4 1 
    10:0 4 2 
    11:0 4 3 
    12:1 0 2 
    13:1 0 3 
    14:1 0 4 
    15:1 2 0 
    16:1 2 3 
    17:1 2 4 
    18:1 3 0 
    19:1 3 2 
    20:1 3 4 
    21:1 4 0 
    22:1 4 2 
    23:1 4 3 
    24:2 0 1 
    25:2 0 3 
    26:2 0 4 
    27:2 1 0 
    28:2 1 3 
    29:2 1 4 
    30:2 3 0 
    31:2 3 1 
    32:2 3 4 
    33:2 4 0 
    34:2 4 1 
    35:2 4 3 
    36:3 0 1 
    37:3 0 2 
    38:3 0 4 
    39:3 1 0 
    40:3 1 2 
    41:3 1 4 
    42:3 2 0 
    43:3 2 1 
    44:3 2 4 
    45:3 4 0 
    46:3 4 1 
    47:3 4 2 
    48:4 0 1 
    49:4 0 2 
    50:4 0 3 
    51:4 1 0 
    52:4 1 2 
    53:4 1 3 
    54:4 2 0 
    55:4 2 1 
    56:4 2 3 
    57:4 3 0 
    58:4 3 1 
    59:4 3 2 
      

  12.   

    看我这个算法：计算部分耗时最大16ms，加上显示最大31ms
    package cxz.math;public class Arrange {
      static int n = 6, m = 6;  public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < n; i++)
          sign[i] = false;
        f(n, m);
        System.out.println("calculate take time:" + (System.currentTimeMillis() - start) + " ms");
        System.out.println(buf.toString());
        System.out.println("total take time:" + (System.currentTimeMillis() - start) + " ms");
      }  private static boolean[] sign = new boolean[n];
      static int count = 0;
      static int num = 0;  public static void f(int n, int m) {
        if (count == m) {
          show();
          return;
        }
        for (int i = 0; i < n; i++) {
          if (!sign[i]) {
            sign[i] = true;
            count++;
            f(n, m);
            count--;
            sign[i] = false;
          }
        }
      }  static StringBuffer buf = new StringBuffer();  public static void show() {
        buf.append((num++)).append(':');
        for (int i = 0; i < n; i++)
          if (sign[i])
            buf.append(i).append(' ');
        buf.append('\n');
      }
    }
      

  13.   

    有点错误，更正一下
    package cxz.math;public class Arrange {
      static int n = 6, m = 6;  public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < n; i++)
          sign[i] = false;
        for (int i = 0; i < m; i++)
          vv[i] = -1;
        f(n, m);
        System.out.println("calculate take time:" + (System.currentTimeMillis() - start) + " ms");
        System.out.println(buf.toString());
        System.out.println("total take time:" + (System.currentTimeMillis() - start) + " ms");
      }  private static boolean[] sign = new boolean[n];
      private static int[] vv = new int[m];
      static int count = 0;
      static int num = 0;  public static void f(int n, int m) {
        if (count == m) {
          show();
          return;
        }
        for (int i = 0; i < n; i++) {
          if (!sign[i]) {
            sign[i] = true;
            int c = count;
            vv[c] = i;
            count++;
            f(n, m);
            count--;
            sign[i] = false;
            vv[c] = -1;
          }
        }
      }  static StringBuffer buf = new StringBuffer();  public static void show() {
        buf.append(num++).append(':');
        for (int i = 0; i < m; i++)
          buf.append(vv[i]).append(' ');
        buf.append('\n');
      }
    }
      

  14.   

    呵呵，花猫同学也用stringBuffer来做，这样一旦数字在10以上，就会出现内存耗尽了顺便贴上小弟的最终版：如果以6为标准，则计算部分0~10ms,加上输出为20ms以内，而且在数字10以上也不会出现内存耗尽的情况public class test{
      String[] list;
      StringBuffer sb = new StringBuffer();
      int len,start,x;
      test(String in){
        len = Integer.parseInt(in);
        list = new String[len];
        for(int i=0;i<len;i++)
          list[i] = String.valueOf(i+1);
        printList();
        System.out.print(sb);
      }
      void replaceStr(int c1,int c2){
        String temp = list[c1];
        list[c1] = list[c2];
        list[c2] = temp;
      }
      void printList(){
        if(start==len-1){
          if(x++>10000000){
            System.out.print(sb);
            sb = new StringBuffer();
          }
          for(int i=0;i<len;i++,x++)
            sb.append(list[i]);
          sb.append(" ");
        }else{
          for(int i=start;i<len;i++){
            replaceStr(start++,i);
            printList();
            replaceStr(i,--start);
          }
        }
      }
      public static void main(String args[]){
        long t1 = System.currentTimeMillis();
        new test(args[0]);
        System.out.println(System.currentTimeMillis()-t1);
      }
    }
      

  15.   

    搞错，if(x++>10000000)漏了个x=0;
      

  16.   

    public class SoreStr {
    private int n=0;
    private void printSoredStr(String[] str,String s) {
    if(str.length<1) {
    n++;
    System.out.println("第"+n+"种排列:"+s);
    return;
    }
    for(int i=0; i<str.length; i++) {
    String[] tem=new String[str.length-1];
    int count=0;
    for(int j=0; j<str.length; j++) {
    if(j==i)
    continue;
    tem[count]=str[j];
    count++;
    }
    this.printSoredStr(tem,s+"\t"+str[i]);
    }
    }
    public void soreCharactors(String[] str) {
    printSoredStr(str,"");
    }
    public static void main(String[] args) {
    String[] str={"1","2","3","4"};
    new SoreStr().soreCharactors(str);
    }
    }
    试试这个,我以前写的~~
      

  17.   

    to  zapdos() ( ) 信誉：100    Blog   加为好友  2007-05-21 16:15:13  得分: 0  
     
     
       呵呵，花猫同学也用stringBuffer来做，这样一旦数字在10以上，就会出现内存耗尽了
    ------------------------
    我用stringBuffer只是为了存储输出结果，如果不显示的话，可以去掉。或者一条条输出，不用stringBuffer。我的意见是数字在10以上，最好是把结果存到文件中去。
      

  18.   

    #include <iostream>
    using namespace std;void swap(int &a,int &b)
    {
    int t=a;
    a=b;
    b=t;
    }//回溯法
    //a[]是需要回溯的数组;
    //目标是求C(n,m)
    //curlen与startIndex是算法中需要的，初始都是0
    void combi(int a[], int n, int m, int curlen, int startIndex)
    {
    if(curlen==m)
    {
    for(int i=0;i<m;i++)
    cout<<a[i];
    cout<<endl;
    }else
    {
    for(int i=startIndex;i<n;i++)
    {
    swap(a[i],a[curlen]);
    combi(a,n,m,curlen+1,i+1);
    swap(a[i],a[curlen]);
    }
    }
    }
    int main()
    {
    int a[]={0,1,2,3,4,5,6,7,8,9};
    //以下示例是求C(10,6)个所有组合
    combi(a,10,6,0,0);
    }程序输出：
    012345
    012346
    012347
    012348
    012349
    012356
    012357
    012358
    012359
    012367
    012368
    012369
    012378
    012379
    012389
    012456
    012457
    012458
    012459
    012467
    012468
    012469
    012478
    012479
    012489
    012567
    012568
    012569
    012578
    012579
    012589
    012678
    012679
    012689
    012789
    013456
    013457
    013458
    013459
    013467
    013468
    013469
    013478
    013479
    013489
    013567
    013568
    013569
    013578
    013579
    013589
    013678
    013679
    013689
    013789
    014567
    014568
    014569
    014578
    014579
    014589
    014678
    014679
    014689
    014789
    015678
    015679
    015689
    015789
    016789
    023456
    023457
    023458
    023459
    023467
    023468
    023469
    023478
    023479
    023489
    023567
    023568
    023569
    023578
    023579
    023589
    023678
    023679
    023689
    023789
    024567
    024568
    024569
    024578
    024579
    024589
    024678
    024679
    024689
    024789
    025678
    025679
    025689
    025789
    026789
    034567
    034568
    034569
    034578
    034579
    034589
    034678
    034679
    034689
    034789
    035678
    035679
    035689
    035789
    036789
    045678
    045679
    045689
    045789
    046789
    056789
    123456
    123457
    123458
    123459
    123467
    123468
    123469
    123478
    123479
    123489
    123567
    123568
    123569
    123578
    123579
    123589
    123678
    123679
    123689
    123789
    124567
    124568
    124569
    124578
    124579
    124589
    124678
    124679
    124689
    124789
    125678
    125679
    125689
    125789
    126789
    134567
    134568
    134569
    134578
    134579
    134589
    134678
    134679
    134689
    134789
    135678
    135679
    135689
    135789
    136789
    145678
    145679
    145689
    145789
    146789
    156789
    234567
    234568
    234569
    234578
    234579
    234589
    234678
    234679
    234689
    234789
    235678
    235679
    235689
    235789
    236789
    245678
    245679
    245689
    245789
    246789
    256789
    345678
    345679
    345689
    345789
    346789
    356789
    456789