java所有组合

Ⅰ java 组合问题：6个A，5个B，一共多少种组合方法

importjava.util.Arrays;
importjava.util.ArrayList;
importjava.util.List;

publicclassMain{
publicstaticvoidmain(String[]args){
List<int[]>list=newArrayList<int[]>();
find(list,11,6);
for(int[]arr:list){
System.out.println(Arrays.toString(arr));
}
System.out.println("Total:"+list.size());
}

privatestaticvoidfind(List<int[]>list,intlength,intcount){
int[]arr=newint[length];
for(inti=0;i<=arr.length-count;i++){
find(list,arr,i,count);
}
}

privatestaticvoidfind(List<int[]>list,int[]arr,intindex,intcount){
arr[index]=1;//为了好看，我这里是1，你可以改成-5。
if(--count==0){
list.add(Arrays.Of(arr,arr.length));
}else{
for(inti=index+1;i<=arr.length-count;i++){
find(list,arr,i,count);
}
}
arr[index]=0;
}
}

Ⅱ 用java找出这几个list，所有可能的组合，并且组合结果的list中的数据不允许重复

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.TreeSet;

public class MyCode {

static TreeSet<String> ts = new TreeSet<>();

static StringBuffer stb = new StringBuffer();

public static void main(String args[]) {

List<Integer> a = new ArrayList<>();

a.add(1);

a.add(2);

a.add(3);

List<Integer> b = new ArrayList<>();

b.add(2);

b.add(3);

b.add(4);

b.add(5);

List<Integer> c = new ArrayList<>();

c.add(5);

c.add(6);

List<Integer> d = new ArrayList<>();

d.add(5);

List<Integer> e = new ArrayList<>();

e.add(7);

String arr[];

List<String> names = (Arrays.asList("a,b,c,d,e".split(",")));

ArrayList<List<Integer>> list = new ArrayList<>();

list.add(a);

list.add(b);

list.add(c);

list.add(d);

list.add(e);

for (int i = 0; i < list.size(); i++) {

List<Integer> temA = new ArrayList<>(list.get(i));

for (int j = i + 1; j < list.size(); j++) {

List<Integer> temB = new ArrayList<>(list.get(j));

temA.retainAll(temB);

if (temA.size() <= 0) {

List<Integer> temC = new ArrayList<>(list.get(i));

List<Integer> temD = new ArrayList<>(list.get(j));

temC.addAll(temD);

stb.append(names.get(i) + "," + names.get(j) + ",");

getNameIndex(temC, list, i, j, names);

arr = stb.toString().split(",");

Arrays.sort(arr);

ts.add(Arrays.toString(arr));

stb.delete(0, stb.length());

}

}

}

for (Iterator<String> it = ts.iterator(); it.hasNext();) {

System.out.println(it.next());

}

}

private static void getNameIndex(List<Integer> listTem, List<List<Integer>> listB, int x, int y,

List<String> names) {

for (int i = 0; i < listB.size(); i++) {

if (i == x || i == y) {

continue;

}

List<Integer> listN = new ArrayList<>(listTem);

List<Integer> listM = new ArrayList<>(listB.get(i));

listN.retainAll(listM);

if (listN.size() <= 0) {

stb.append(names.get(i));

break;

}

}

}

}

你这个,麻雀虽小,五脏俱全呢,看似一个简单的小玩意,挺费劲的!

主要用的是交集,并集,难点就是因为嵌套,有点饶头..你自己琢磨一下吧!

Ⅲ Java数组分成N个数组的所有组合

这个问题不是这么想的，
你可以想象一个n位二进制的数，找出所有只有k个1，其他位都是0的数，这个二进制数的第x位为1就表示取字母表中的第x个字母，为0不取，最后得到的就是这个二进制数代表的组合，将所有的二进制数都翻译成字母组合后，就是你要取得的所有字母组合了。

如果实在不会的话，待会再给你写个代码

public class Combination {
public static void main(String[] args) {
String[] valueSets = { "a", "b", "c", "d", "e" };
int n = 3;
List<String> list = combination(valueSets, n);
System.out.println(list);
for(String string: list){
System.out.println(string);
}
System.out.println("一共 "+list.size()+" 个。");
}

public static List<String> combination(String[] valueSets, int n) {
System.out.println(">>>>>combination");
List<String> binaryList = searchBinaryList(valueSets.length, n);
List<String> combinationList = toCombinationList(binaryList, valueSets);
return combinationList;
}

public static List<String> toCombinationList(List<String> binaryList,
String[] valueSets) {
List<String> combinationList = new ArrayList<String>();
for (String binary : binaryList) {
String combination = changeBinaryToCombination(binary, valueSets);
if (combination != null && combination.trim() != "") {
combinationList.add(combination);
}
}
return combinationList;
}

public static String changeBinaryToCombination(String binary,
String[] valueSets) {
String combination = "";
if (binary == null || binary.trim() == "") {
return null;
}
for (int i = 0; i < binary.length(); i++) {
if (binary.charAt(i) == '1') {
combination += valueSets[i];
}
}
return combination;
}

public static List<String> searchBinaryList(int length, int n) {
System.out.println(">>>>>searchBinaryList");
List<String> binaryList = new ArrayList<String>();
for (int i = 0; i < (int) Math.pow(2, length); i++) {
String binary = Integer.toBinaryString(i);
int count = oneCountsContainsInBinary(binary);
if (count == n) {
binaryList.add(toSpecifiedBitsBinary(binary, length));
}
}
return binaryList;
}

public static String toSpecifiedBitsBinary(String binary, int length) {
String specifiedBitsBinary = "";
for (int i = 0; i < length - binary.length(); i++) {
specifiedBitsBinary += 0;
}
specifiedBitsBinary += binary;
return specifiedBitsBinary;
}

public static int oneCountsContainsInBinary(String binary) {
int count = 0;
if (binary == null || binary.trim() == "") {
return count;
}
for (int i = 0; i < binary.length(); i++) {
if (binary.charAt(i) == '1') {
count++;
}
}
return count;
}
}

Ⅳ java实现数组的所有组合

细节上需要改进。import java.util.*;
public class Map {
Vector<int[]> v = new Vector<int[]>();
Vector<Integer> vv = new Vector<Integer>(); Map() {
int[] array = { 1, 2, 3, 4, 5 };
Scanner s = new Scanner(System.in);
int x = s.nextInt();
pro(array, 0, x);
for(int i=0;i<v.size();i++){
int[] r=v.get(i);
for(int j=0;j<r.length;j++){
System.out.print(""+r[j]+",");
}
System.out.println();
}
} public void pro(int[] a, int start, int n) {
if (n == 0) {
int[] r = new int[vv.size()];
for (int i = 0; i < r.length; i++) {
r[i] = vv.get(i);
}
v.add(r);
return;
}
if (start >= a.length) {
return;
}
for (int i = start; i < a.length; i++) {
vv.add(a[i]);
pro(a, i + 1, n - 1);
vv.remove(vv.size()-1);
}
} public static void main(String arg[]) {
new Map();
}
}

Ⅳ Java中 任意几个数字获取其所有的排列组合

数组排序有专门的API，这里就不说了获取1-30的5个随机数即可使数组的下标和里面的值相同，那么 可以通过 数组[26-当前下标] 是否被去除 来输出 int a[] = new int[31]; // 赋值，去除 for(int i=1;i<26/2;i++){ if(a[i]!=0 && a[26-i]!=0) 输出；若一定要5个数都有。则5*4*3*2*1=120若不一定要5个数字，则1个:5种2个：5*4=203个：5*4*3=604个：5*4*3*2=1205个:120总：5+20+60+120+120=325

Ⅵ 关于JAVA组合排列的实现

importjava.util.Arrays;
importjava.util.LinkedList;

publicclassRecursionNArray
{
privatestaticLinkedList<char[]>recursionSub(LinkedList<char[]>list,intcount,char[][]array,intind,
intstart,int...indexs)
{
start++;
if(start>count-1)
{
returnnull;
}
if(start==0)
{
indexs=newint[array.length];
}
for(indexs[start]=0;indexs[start]<array[start].length;indexs[start]++)
{
recursionSub(list,count,array,0,start,indexs);
if(start==count-1)
{
char[]temp=newchar[count];
for(inti=count-1;i>=0;i--)
{
temp[start-i]=array[start-i][indexs[start-i]];
}
list.add(temp);
}
}
returnlist;
}

publicstaticvoidmain(String[]args)
{
char[]a={'中','国','有','个','人'};
char[]b={'中','国','有','个','人'};
char[]c={'中','国','有','个','人'};
char[]d={'中','国','有','个','人'};
char[][]temp={a,b,c,d};

LinkedList<char[]>list=newLinkedList<char[]>();
recursionSub(list,temp.length,temp,0,-1);
for(inti=0;i<list.size();i++)
{
System.out.println(Arrays.toString(list.get(i)).replaceAll("[\[\]\,\s]",""));
}
}
}

Ⅶ java怎么找一个数组的所有组合

用递归应该可以实现 小数组的处理 大数组就有点吃不消了

另开一个标记数组 标记取过的数
确定要取几个数来组合 n
取第一个数 标记下标 每次递归排除已标记下标 达到n后将标记过的数据加起来 存入新数组

Ⅷ java 所有组合

public static void main(String[] args) {
String s="123";
char[] ss= s.toCharArray();
StringBuffer set= new StringBuffer();
for(int i=0;i<6;i++){//6是所有组合总数,也就是ss.length 值的阶乘
set.delete(0,set.length());
for(int j=0;j<ss.length;j++){
set.append(ss[(i+j)%ss.length]);
}
System.out.println(set.toString());
}
}

Ⅸ java找出数字的所有组合

package com.zy.test2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class TestDi {
public static void main(String[] args) {
String s[] = {"1", "2", "3"};
List<String> list = new ArrayList<String>();
listAll(Arrays.asList(s), "", list);
Collections.sort(list);
for (String str : list)
{
System.out.println(str);
}
}

public static void listAll(List<?> candidata, String prefix, List<String> list)
{
if (prefix != null && prefix != "")
{
list.add(prefix);
}
for (int i = 0; i < candidata.size(); i++)
{
List<?> temp = new LinkedList<>(candidata);
listAll(temp, prefix + temp.remove(i), list);
}
}
}