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+="+";
			}
		}
	}
}