编程算法,java,组合:求出n个数中取出k个数的组合,编程终于成功了!!!!需要的自己参考一下哈,哈哈

Posted 2023-04-19

package combination_n_k;
/*n个数选择k个出来
* 123456789,选择4个
* 首先肯定是1234
* 其次1235,1236...
* 最后是6789,跳出循环
*
* 由本组合推出下一个组合,递推思想:
* 把本组合与最后一组合 倒回来个相比较
* :1234---6789,4<9,4+1=5-->1235,1236
* 后面的依次加一
* 3589-->36,6+1,6+1+1
*
* 最后看是否到了最后一个组合,跳出循环
*
*
* */
public class Test1

public static void main(String[] args)
int n = 7;
int k = 3;
com(n, k);


// 组合函数
static void com(int n, int k) // 1-n里面取k个组合
if (n < k || n <= 0 || k <= 0)
System.out.println("n,k数据输入不合理");
return;

int[] a = new int[k + 1];
int[] fg = new int[k + 1];// 标记对照
int count = 1;

for (int i = 1; i <= k; i++)
a[i] = i;
fg[i] = i - k + n;// 12345,3,fg就是(345)

while (true)
System.out.print("第" + (count++) + ":\t");
for (int i = 1; i <= k; i++)
System.out.print(a[i] + "\t");
System.out.println();

if (a[1] == n - k + 1)
break;// 跳出条件

for (int i = k; i >= 1; i--)
if (a[i] < fg[i]) // 那个数小于标记,加一
a[i]++;// 123456789,3589->3678(5->6,6+1,6+1+1)
for (int j = i + 1; j <= k; j++)
a[j] = a[j - 1] + 1;// 后面的数,依次加一升序
break;
// if
// for i

// while

参考技术A 刚刚开始学java的飘过。。。。不会。。。。 参考技术B 深奥啊

不懂啊本回答被提问者采纳

获取所有组合算法获取全排列算法（java）

转载声明：原文转自:http://www.cnblogs.com/xiezie/p/5574516.html 

受到ACM1015的影响，个人感觉，有必要对统计学上的 全组合和全排列 进行一个简单的总结

 

组合数：从m个不同元素中取出n（n≤m）个元素的所有组合的个数，叫做从m个不同元素中取出n个元素的组合数（Combination）。

如1,2,3三个元素的全组合为：

1
2
3
12
13
23
123

以下是java实现的获取全组合及其个数的算法：

import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class GetCombination {

    public static void main(String[] args) {
        Scanner scan = new Scanner(new BufferedInputStream(System.in));
        String s = scan.next();
        ArrayList<String> list = new ArrayList<>();
        ArrayList<Character> com = new ArrayList<>();
        int len = s.length() + 1;
        for(int i = 1 ; i != len ; i ++){
            getCombinations(list,s.toCharArray(),0,i,com);
        }
        for(int i = 0 ; i != list.size() ; i ++){
            System.out.println(list.get(i));
        }
        System.out.println(getCountOfCombinations(s.length(),s.length()));
        scan.close();
    }
    
    static void getCombinations(ArrayList<String> list ,char[] cs, int start,int len,ArrayList<Character> com){//len为组合的长度
        if(len == 0){
            String s = "";
            for(int i = 0 ; i != com.size() ; i ++){
                s = s.concat(com.get(i).toString());
            }
            list.add(s);
            return;
        }
        if(start==cs.length){
            return;
        }
        com.add(cs[start]);
        getCombinations(list,cs,start+1,len-1,com);
        com.remove(com.size()-1);
        getCombinations(list,cs,start+1,len,com);
    }
    
    static int getCountOfCombinations(int arrLen,int len){//获取长度为len的组合数
        int m = 1;
        for(int i = 0 ; i != len ; i ++ ){
            m*=arrLen-i;
        }
        int n = 1;
        for(int i = len ; i != 1 ; i --){
            n*=i;
        }
        return m/n;
    }
    
}

 

 

 

 

全排列：从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。

如1,2,3三个元素的全排列为：
1,2,3
1,3,2
2,1,3
2,3,1
3,1,2
3,2,1
共3*2*1=6种 3！

以下是java实现的获取全排列及其个数的算法：

import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class GetAllPermutations {

    public static void main(String[] args) {
        Scanner scan = new Scanner(new BufferedInputStream(System.in));
        String s = scan.next();
        ArrayList<String> list = new ArrayList<>();
        getAllPermutations(list,s.toCharArray(),0,s.length());
        System.out.println("----------非字典序----------");
        for(int i = 0 ; i != list.size() ; i ++){
            System.out.println(list.get(i));
        }
        list.clear();
        System.out.println("----------字典序----------");
        getAllPermutations2(list,s.toCharArray(),0,s.length());
        for(int i = 0 ; i != list.size() ; i ++){
            System.out.println(list.get(i));
        }
        System.out.println(getCountOfAllPermutations(s.toCharArray(),0,s.length()));
        scan.close();
    }

    static int getCountOfAllPermutations(char[] cs,int start,int len){//start为数组序号
        int count = 1;
        int n = start + len ;
        for(int i = start ; i != n ; i ++ ){
            count *= i+1;
        }
        return count;
    }

    //非字典序
    static void getAllPermutations(ArrayList<String> answers,char[] cs,int start,int len){
        if(start == len ){
            answers.add(String.valueOf(cs));
            return;
        }
        for(int i = start ; i != len ; i ++){
            swap(cs,i,start);
            getAllPermutations(answers,cs,start+1,len);
            swap(cs,i,start);
        }
    }
    
    //字典序
    static void getAllPermutations2(ArrayList<String> list, char[] cs, int i, int length) {
        sort(cs);
        permutations(list,cs,i,length);
    }
    
    static void sort(char[] a) {//对字符数组进行快排
        int len = a.length;
        int low = 0,high = len - 1;
        quickSort(a, low, high);
    }

    static void quickSort(char[] a, int l ,int h){
        if(l>=h){
            return;
        }
        int low = l;
        int high = h;
        char k = a[low];
        while(low< high){
            //
            while(high>low&&a[high]>=k){//寻找元素右边比其小的
                high --;
            }
            a[low] = a[high];//进行交换，K指向high
            while(low<high&&a[low]<=k){//寻找元素左边比其大的
                low++;
            }
            a[high] = a[low];//进行交换，K指向low
        }
        a[low] = k;//将K赋给low
        quickSort(a, l, low-1);
        quickSort(a, low+1, h);
    }

    static void permutations(ArrayList<String> answers,char[] cs,int start,int len){//cs为字典序数组
        if(cs==null)
            return;
        while(true)
        {
            answers.add(String.valueOf(cs));
            int j=start+len-2,k=start+len-1;
            while(j>=start && cs[j]>cs[j+1])
                --j;
            if(j<start)
                break;

            while(cs[k]<cs[j])
                --k;

            swap(cs,k,j);

            int a,b;
            for(a=j+1,b=start+len-1;a<b;++a,--b)
            {
                swap(cs,a,b);
            }
        }
    }

    static void swap(char[] cs , int i , int j){
        char t;
        t = cs[i];
        cs[i] = cs[j];
        cs[j] = t;
    }
}