java數組排列組合_Java數組分成N個數組的所有組合

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

2. 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

3. 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;
}
}
}
}
}

4. 列出n的排列組合出現的全部情況(java)

曾經，我為這個問題困惑了很久，實現不了。
不過現在我終於搞定了排列組合，且看代碼
package math;
public class Arrangement {
public static final String CUT=",";
public static final String ONE_CUT="\r\n";
public static void main(String[] args){
int n=3;//排列組合數
StringBuffer sb=new StringBuffer();//組合結果
getCombination(sb,n);//組合結果
System.out.println(n+"的組合結果：");
String result=sb.toString();
System.out.println(result);

//排列結果
System.out.println("=============");
System.out.println(n+"的排列結果：");
//n的排列結果集
StringBuffer permuResult=new StringBuffer();
getPermutations(result,permuResult);
System.out.println(permuResult);
}

public static void getCombination(StringBuffer sb,int maxNum){
for(int t=1;t<=maxNum;t++){
getOrder("","",sb,1,maxNum,t);
}
}

public static void getOrder(String preString,String preShow,StringBuffer result,int start,int end,int len){
if(len-preString.length()==1){//這是這個組合結果的最後一次選擇
for(int i=start;i<=end;i++){
if(!preString.equals("")){
result.append(preShow).append(CUT).append(i).append(ONE_CUT);
}else{
result.append(preShow).append(i).append(ONE_CUT);
}
}
}else{//否則遞歸調用
for(int i=start;i<end;i++){
//preString添加i後遞歸調用getOrder（）
if(!preString.equals("")){
getOrder(preString+i,preShow+CUT+i,result,i+1,end,len);
}else{
getOrder(preString+i,preShow+i,result,i+1,end,len);
}
}
}
}

/**
* 所有的排列結果相當於在所有的組合結果里
* 把每一個組合結果(假設組合結果長度為m)做A(m,m)排列
* @param comResult
* @param sb
*/
public static void getPermutations(String comResult,StringBuffer sb){
//組合結果數組
String[] comArry=comResult.split(ONE_CUT);
for(int i=0;i<comArry.length;i++){
if(comArry[i].trim().equals("")){
continue;
}
String[] strArry=comArry[i].split(CUT);
//吧字元串數組變成數字數組
int[] arry=toIntArray(strArry);
//求每一個組個結果的A（m,m）排列
getPermutations("","",sb,arry);
}
}

public static int[] toIntArray(String[] strArry){
int[] arry=new int[strArry.length];
for(int i=0;i<arry.length;i++){
arry[i]=Integer.valueOf(strArry[i]);
}
return arry;
}

public static void getPermutations(String preString,String preShow,StringBuffer sb,int[] arry){

// 最終的組合結果長度m,我們需要做m次選擇
if(arry.length==1){//剩餘要選擇的次數如果等於1
//直接把最後這個數添加到這個排列結果
if(!preString.equals("")){
sb.append(preShow).append(CUT).append(arry[0]).append(ONE_CUT);
}else{
sb.append(preShow).append(arry[0]).append(ONE_CUT);
}
}else{//否則，遞歸調用本方法
for(int i=0;i<arry.length;i++){
//arry移除第i項的數組
int[] pNext=getSubArray(arry,i);
//把選擇的array[i]添加到結果
if(!preString.equals("")){
getPermutations(preString+arry[i],preShow+CUT+arry[i],sb,pNext);
}else{
getPermutations(preString+arry[i],preShow+arry[i],sb,pNext);
}
}
}
}

public static int[] getSubArray(int[] pArry,int index){
int[] result=new int[pArry.length-1];
int tem=0;
for(int i=0;i<pArry.length;i++){
if(i==index){
continue;
}
result[tem]=pArry[i];
tem++;
}
return result;
}
}

其中的n樓主可以改成其他的試一試，不過千萬不要改的太大，否則機器會崩潰的，因為排列結果數會隨著n的增大而成爆炸性增長。本想傳張控制台顯示結果的圖片，可經驗告訴我，那樣提交答案經常不顯示出來。所以，趕快去跑跑試試吧！！

5. java數組排列，學渣求解

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

就是這是個升序！

其次，你這個運行應該不會報錯，輸出的會是數組地址，因為數組在java裡面是一個對象，如果要看排序的結果，需要遍歷下：
比如
for(int i:arr){
System.out.println(i);
}

6. 將兩個數組排列組合到一個數組集合求java 代碼

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Test {

private String[] arr1;
private String[] arr2;

public Test(){
//數組長度可以隨意改，但必須保證兩個數組長度一樣
arr1 = new String[3];
arr2 = new String[3];
initArray();
}

private void initArray(){
Scanner scanner = new Scanner(System.in);
for(int i=0;i<arr1.length;i++){
arr1[i] = scanner.next();
}
for(int i=0;i<arr2.length;i++){
arr2[i] = scanner.next();
}
}
/**
* 獲取組合後的數組表單
* @return
*/
private List<String[]> getcombineList(){
List<String[]> list = new ArrayList<String[]>();
combineArray(list, arr1, arr2);
combineArray(list, arr2, arr1);
return list;
}
/**
* 遍歷數組str1，並將其復制到新的數組，再將str2中索引值與str1中索引值
* 相同的元素放入新的數組，然後將新的數組放入list中
* @param list
* @param str1
* @param str2
*/
private void combineArray(List<String[]> list,String[] str1, String[] str2){
for(int i=0; i<str1.length; i++){
String[] str = new String[str1.length];
for(int j=0; j<str2.length; j++){
str[j] = str2[j];
if(i == j)
str[j] = str1[j];
}
System.out.println(getArrayMessage(str));
list.add(str);
}
}

/**
* 將數組每一個元素組合成字元串
* @param str 字元串數組
* @return 組合字元串
*/
private String getArrayMessage(String[] str){
StringBuffer buffer = new StringBuffer();
for(int i=0; i<str.length; i++){
if(i == str.length-1)
buffer.append(str[i]);
else
buffer.append(str[i]).append(",");
}
return buffer.toString();
}

public static void main(String[] argv){
Test test = new Test();
test.getcombineList();
}
}

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

採納吧

8. java全排列數組

全排列演算法很多，這是其中一個，使用遞歸——

import java.util.ArrayList;
import java.util.List;
public class PermAComb {
static List<int[]> allSorts = new ArrayList<int[]>();

public static void permutation(int[] nums, int start, int end) {
if (start == end) { // 當只要求對數組中一個數字進行全排列時，只要就按該數組輸出即可
int[] newNums = new int[nums.length]; // 為新的排列創建一個數組容器
for (int i=0; i<=end; i++) {
newNums[i] = nums[i];
}
allSorts.add(newNums); // 將新的排列組合存放起來
} else {
for (int i=start; i<=end; i++) {
int temp = nums[start]; // 交換數組第一個元素與後續的元素
nums[start] = nums[i];
nums[i] = temp;
permutation(nums, start + 1, end); // 後續元素遞歸全排列
nums[i] = nums[start]; // 將交換後的數組還原
nums[start] = temp;
}
}
}

public static void main(String[] args) {
int[] numArray = {1, 2, 3, 4, 5, 6};
permutation(numArray, 0, numArray.length - 1);
int[][] a = new int[allSorts.size()][]; // 你要的二維數組a
allSorts.toArray(a);

// 列印驗證
for (int i=0; i<a.length; i++) {
int[] nums = a[i];
for (int j=0; j<nums.length; j++) {
System.out.print(nums[j]);
}
System.out.println();
}
System.out.println(a.length);
}
}

9. 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數組排列組合

java數組排列組合

與java數組排列組合相關的資料