java数组排列组合

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