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);
}
}
}