java数组的排列组合

‘壹’ 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.io.File;
import java.util.*;
import java.util.Random;
import java.util.Scanner;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.io.FileNotFoundException;

public class TheDa {

public static void main(String args[]) throws Exception {
System.out.println("please input the name for the list");
Scanner inputReader = new Scanner(System.in);
String TheDalist = inputReader.nextLine();
String[] newstr=TheDalist.split("\\s+");
if (newstr.length !=4) { System.out.println("the length is not ok"); }
else {
if ((newstr[0].equals("Joe")) && (newstr[1].equals("William")) &&(newstr[2].equals("Jack")) && (newstr[3].equals("Averell"))) {
System.out.println("True");
}
else if ((newstr[0].equals("Averell")) && (newstr[1].equals("Jack")) &&(newstr[2].equals("William")) && (newstr[3].equals("Joe"))) {
System.out.println("True");
}
else {
System.out.println("False");
}
}
}

}

‘叁’ java 排列组合问题

import java.io.*;
public class Test {
public static void main(String args[]) {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要排序的个数:");
String str=null;
try {
str=br.readLine();
} catch(IOException e) {}
int num=0;
int data[];
try {
num=Integer.parseInt(str);
System.out.println("请输入"+num+"个数,以空格隔开");
String line=br.readLine();
data=new int[num];
String temp[]=new String[num];
temp=line.split(" ");
for (int i=0;i<num;i++) {
data[i]=Integer.parseInt(temp[i]);
}
sort(data);
} catch(NumberFormatException e) {
System.out.println("数据格式不正确");
} catch(IOException e) {}
}
//数组排序方法
public static void sort(int [] d) {
int l=d.length;
for (int i=0;i<l-1;i++) {
for (int j=0;j<l-1-i;j++) {
if (d[i]>d[i+1]) {
int temp=d[i];
d[i]=d[i+1];
d[i+1]=temp;
}
}
}
}
}

‘肆’ java排列组合算法

//这个程序是以前用高分求来的,现在稍作修改，呵呵
public class Zuhe {

public static void main(String[] args) {
String s = "122345";//这里是要用到的所有数组成的一个字符串,其它字符同样适用
char[] c = s.toCharArray();
new Zuhe().zuhe(c,c.length,0);
System.out.println("可能的组合数："+kk);
}
static int kk=0;
private void zuhe(char[] array, int n, int k) {
if (n == k) {
if(array[2]!='4'){//第三个位置不能出现4
String str = new String(array);
if(str.indexOf("53")<0&&str.indexOf("35")<0){//3，5不能连续出现
System.out.println(str);
++kk;
}
}
} else {
for (int i = k; i < n; i++) {
swap(array, k, i);
zuhe(array, n, k + 1);
swap(array, i, k);
}
}
}

private void swap(char[] a, int x, int y) {
char temp = a[x];
a[x] = a[y];
a[y] = temp;
}
}

========结果=========
122345
122543
123245
123254
123425
123452
125432
125423
125243
125234
122345
122543
123245
123254
123425
123452
125432
125423
125243
125234
132245
132254
132425
132452
132542
132524
132245
132254
132425
132452
132542
132524
142325
142523
143225
143252
143225
143252
142325
142523
145232
145223
145223
145232
152342
152324
152432
152423
152243
152234
152342
152324
152432
152423
152243
152234
212345
212543
213245
213254
213425
213452
215432
215423
215243
215234
221345
221543
223145
223154
223415
223451
225431
225413
225143
225134
232145
232154
232415
232451
232541
232514
231245
231254
231425
231452
231542
231524
242315
242513
243215
243251
243125
243152
241325
241523
245132
245123
245213
245231
252341
252314
252431
252413
252143
252134
251342
251324
251432
251423
251243
251234
221345
221543
223145
223154
223415
223451
225431
225413
225143
225134
212345
212543
213245
213254
213425
213452
215432
215423
215243
215234
231245
231254
231425
231452
231542
231524
232145
232154
232415
232451
232541
232514
241325
241523
243125
243152
243215
243251
242315
242513
245231
245213
245123
245132
251342
251324
251432
251423
251243
251234
252341
252314
252431
252413
252143
252134
322145
322154
322415
322451
322541
322514
321245
321254
321425
321452
321542
321524
325142
325124
325412
325421
325241
325214
322145
322154
322415
322451
322541
322514
321245
321254
321425
321452
321542
321524
325142
325124
325412
325421
325241
325214
312245
312254
312425
312452
312542
312524
312245
312254
312425
312452
312542
312524
315242
315224
315422
315422
315242
315224
342125
342152
342215
342251
342521
342512
341225
341252
341225
341252
341522
341522
342125
342152
342215
342251
342521
342512
345122
345122
345212
345221
345221
345212
422315
422513
423215
423251
423125
423152
421325
421523
425132
425123
425213
425231
422315
422513
423215
423251
423125
423152
421325
421523
425132
425123
425213
425231
432215
432251
432125
432152
432512
432521
432215
432251
432125
432152
432512
432521
431225
431252
431225
431252
431522
431522
412325
412523
413225
413252
413225
413252
412325
412523
415232
415223
415223
415232
452312
452321
452132
452123
452213
452231
451322
451322
451232
451223
451223
451232
452312
452321
452132
452123
452213
452231
522341
522314
522431
522413
522143
522134
523241
523214
523421
523412
523142
523124
521342
521324
521432
521423
521243
521234
522341
522314
522431
522413
522143
522134
523241
523214
523421
523412
523142
523124
521342
521324
521432
521423
521243
521234
542321
542312
542231
542213
542123
542132
543221
543212
543221
543212
543122
543122
542321
542312
542231
542213
542123
542132
541322
541322
541232
541223
541223
541232
512342
512324
512432
512423
512243
512234
513242
513224
513422
513422
513242
513224
512342
512324
512432
512423
512243
512234
可能的组合数：396

‘伍’ 求java实现String list[] = { "1", "2", "3" }; 的排列组合代码

对于这个问题，我首先需要纠正一下楼主的措辞，这是个组合问题，跟排列无关，用排列组合亦不恰当。下面说下我的想法
元素不能重复，首先应该去掉相同的元素，最好的办法是用set来实现。参考api
Arrays.asList
set.addAll
其实呢，这个是一个递归的过程，考虑下面情况
对于数组
{“1”}，它的组合数就是{“1”}。
如果再加上一个元素“2“到上面的数组中，那么，如果这个”2“不用，实质上跟{"1"}的情况是一样的，这与不能重复相矛盾，所以”2“一定要用，就是在"1"中再加上”2“；于是我们得到
对于数组{”1“，”2“}它的组合数是{”1“}
再加入一个{”2“}。也许你也考虑到另外一种情况，即”2“也是它的一个组合数，我们考虑丢了，为什么呢，因为在{”1“}中实质上还有一个称为空的集合。这样的话，重新整理一下：
1.对于list
=
{"1"},它的组合包括
{"1"},以及
empty.
2.对于list={"1","2"},它的组合包括{”1“，”2“}（在{”1“}中加了”2“），{”2“}（在empty中加入”2“），也许你还会讲还应该包括{”1“}，但是这个{”1“}我们已经在第1步就已经算出来了，不用再考虑了。
按照这样的规则进行下去，你会发现这样就把所有的组合数遍历出来了。要具体的代码就等会儿，我现在有事。

‘陆’ java的排列组合问题

这个方法没有办法从根本上修改，因为你是循环N的M次方来寻找合适的排列。因此只需要加一个过滤条件将不合适的排列过滤掉剩下的就是组合的个数。因为组合是不考虑元素顺序的，因此只需要让排列中的元素是从小到大或从大到小的就可以了。
你把if(k == 0)这个大括号中的代码改成这样
if (k == 0) {
boolean isFlag = true;
for(int g = 0; g<M-1 && isFlag ;g++){
if(val[g]>=val[g+1]){
isFlag = false;
}
}
if (isFlag) {
System.out.printf("%5d 个是 ", (++nPerm));
for (int l = M - 1; l >= 0; --l) {
System.out.printf("%2d ", val[l]);
}
System.out.println();
}
used[val[k]] = false;
val[k] = val[k] + 1;
}

‘柒’ java 定义了5个数字的数组，显示输出所有的排列组合

importjava.util.ArrayList;
importjava.util.List;
publicclassPermAComb{
staticList<int[]>allSorts=newArrayList<int[]>();

publicstaticvoidpermutation(int[]nums,intstart,intend){
if(start==end){//当只要求对数组中一个数字进行全排列时，只要就按该数组输出即可
int[]newNums=newint[nums.length];//为新的排列创建一个数组容器
for(inti=0;i<=end;i++){
newNums[i]=nums[i];
}
allSorts.add(newNums);//将新的排列组合存放起来
}else{
for(inti=start;i<=end;i++){
inttemp=nums[start];//交换数组第一个元素与后续的元素
nums[start]=nums[i];
nums[i]=temp;
permutation(nums,start+1,end);//后续元素递归全排列
nums[i]=nums[start];//将交换后的数组还原
nums[start]=temp;
}
}
}

publicstaticvoidmain(String[]args){
int[]numArray={1,2,3,4,5,6};
permutation(numArray,0,numArray.length-1);
int[][]a=newint[allSorts.size()][];//你要的二维数组a
allSorts.toArray(a);

//打印验证
for(inti=0;i<a.length;i++){
int[]nums=a[i];
for(intj=0;j<nums.length;j++){
System.out.print(nums[j]);
}
System.out.println();
}
System.out.println(a.length);
}
}

采纳吧

‘捌’ java 数组顺序排列

首先，API里面写了: Sorts the specified array of ints into ascending numerical order.

就是这是个升序！

其次，你这个运行应该不会报错，输出的会是 数组地址，因为数组在java里面是一个对象，如果要看排序的结果，需要遍历下：
比如
for(int i:arr){
System.out.println(i);
}

‘玖’ java实现排列组合

char[] a={'1','2','3','4'};

String b= "";

String c= "";

for (int i = 0; i < a.length-1; i++) {

b="["+a[i]+","+a[i+1]+"]";

c+=b;

}

System.out.println(c);

‘拾’ Java的排列组合问题

packagecom;

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

publicclassKyo
{
	publicstaticvoidrecursionSub(LinkedList<int[]>list,intcount,int[]array,intind,
	intstart,int...indexs)
	{
		start++;
		if(start>count-1)
		{
			return;
		}
		if(start==0)
		{
			indexs=newint[array.length];
		}
		for(indexs[start]=ind;indexs[start]<array.length;indexs[start]++)
		{
			recursionSub(list,count,array,indexs[start]+1,start,indexs);
			if(start==count-1)
			{
				int[]temp=newint[count];
				for(inti=count-1;i>=0;i--)
				{
					temp[start-i]=array[indexs[start-i]];
				}
				list.add(temp);
			}
		}
	}

	publicstaticvoidmain(String[]args)
	{
		Scannerscanner=newScanner(System.in);
		System.out.println("输入n的值:");
		intn=scanner.nextInt();
		int[]A=newint[n];
		int[]B=newint[n];
		System.out.println("输入A数组的值:");
		for(inti=0;i<n;i++)
		{
			A[i]=scanner.nextInt();
		}
		System.out.println("输入B数组的值:");
		for(inti=0;i<n;i++)
		{
			B[i]=scanner.nextInt();
		}
		System.out.println("A:"+Arrays.toString(A));
		System.out.println("B:"+Arrays.toString(B));
		System.out.println("输入k的值:");
		intk=scanner.nextInt();
		scanner.close();
		LinkedList<int[]>listA=newLinkedList<int[]>();
		recursionSub(listA,k,A,0,-1);
		LinkedList<int[]>listB=newLinkedList<int[]>();
		recursionSub(listB,k,B,0,-1);
		intresult=0;
		Stringtmp="",bnp="";
		for(inti=0;i<listA.size();i++)
		{
			int[]as=listA.get(i);
			int[]bs=listB.get(i);
			intsum=0;
			for(intj=0;j<as.length;j++)
			{
				sum+=as[j];
			}
			intmul=1;
			for(intj=0;j<bs.length;j++)
			{
				mul*=bs[j];
			}
			intw=sum*mul;
			result+=w;
			Stringy="x"+(i+1);
			System.out.println(y+"="+w);
			tmp+=y;
			bnp+=w;
			if(i==listA.size()-1)
			{
				System.out.println("∑x"+"="+tmp+"="+bnp+"="+result);
			}
			else
			{
				tmp+="+";
				bnp+="+";
			}
		}
	}
}