java全排列演算法

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

㈡ java中，用遞歸方法求n個數的無重復全排列，n=3。

程序如下所示，輸入格式為：

5
31212

第一行是數字個數，第二行有n個數，表示待排列的數，輸入假設待排序的數均為非負數。

importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.Arrays;
importjava.util.Scanner;

publicclassMain{
staticfinalintmaxn=1000;
intn;//數組元素個數
int[]a;//數組

boolean[]used;//遞歸過程中用到的輔助變數，used[i]表示第i個元素是否已使用
int[]cur;//保存當前的排列數

//遞歸列印無重復全排列，當前列印到第idx位
voidprint_comb(intidx){
if(idx==n){//idx==n時，表示可以將cur輸出
for(inti=0;i<n;++i){
if(i>0)System.out.print("");
System.out.print(cur[i]);
}
System.out.println();
}

intlast=-1;//因為要求無重復，所以last表示上一次搜索的值
for(inti=0;i<n;++i){
if(used[i])continue;

if(last==-1||a[i]!=last){//不重復且未使用才遞歸下去
last=a[i];
cur[idx]=a[i];

//回溯法
used[i]=true;
print_comb(idx+1);
used[i]=false;
}
}
}

publicvoidgo()throwsFileNotFoundException
{
Scannerin=newScanner(newFile("data.in"));

//讀取數據並排序
n=in.nextInt();
a=newint[n];
for(inti=0;i<n;++i)a[i]=in.nextInt();
Arrays.sort(a);

//初始化輔助變數並開始無重復全排列
cur=newint[n];
used=newboolean[n];
for(inti=0;i<n;++i)used[i]=false;
print_comb(0);
in.close();
}

publicstaticvoidmain(String[]args)throwsFileNotFoundException{
newMain().go();
}
}

客觀來說，非遞歸的無重復全排列比較簡單且高效。

㈢ Java數組的全排列，裡面布爾類型的數組vis[ ]，在遞歸演算法里起了什麼作用，遞歸那塊理解不了，求詳細解答

不要急於看代碼，你心理要知道全排列的思路，不注重思路是很多程序員易犯的錯誤。
全排列演算法：
如果我求得固定第一位後的排列，那麼全部排列就可以求出，固定第一位有10種可能，可以循環求得。
如果我求得固定第二位後的排列，固定第一位後的排列就可以求出，固定第二位有9種可能，可以循環求得。
。。。
如果我求得固定第10位後的排列，固定第9位後的排列就可以求出，固定第10位有1種可能，可以循環求得。
這很明顯是遞歸的演算法。
static void dfs(int start,int end,int num){//為全部排列的集合，start為數字的位置,end為最後一位，num多餘的
if(start==end){//當前的數字位置為最後一位時，說明，一個序列已經生成
for(int i=1;i<end;i++)
System.out.print(a[i]+" ");//輸出序列
System.out.println();
}
else{//序列沒有生成時
for(int i=1;i<end;i++){
if(vis[i])//i是否在前面使用過
continue;//如果是直接跳過
a[start]=i;//確定start位置的數字，當start為1時就是確定第一位，有10種可能
vis[i]=true;//設置i為已使用狀態，避免下一位使用i
dfs(start+1,end,num);//求得確定start位後的全部序列
vis[i]=false;//設置i為未使用狀態
}
}

㈣ JAVA演算法面試題：哪位高人會做

就把演算法給你寫一下：
for(int i = 1;i<=n;i++)
for(int j = 1;j<=n;j++)
for(int k = 1;k<=n;k++)
{
if(i==j || i==k || j==k)
continue;
else
System.out.println(i*100+j*10+k);

}

㈤ Java實現幾個字母的所有組合

1樓扯淡，二樓網上復制的，不完全符合要求，3樓的有些問題，不能輸出所有的不是貶低各位
這是我在2樓基礎上改的
package main;

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

public class Test {

public static void main(String[] args) {
String s="abcdaaa";
ger(split(s,true));

}
/**
*
* @param target
* @param isDeleteRepeat 是否去掉重復的字母例如abcda去重則為abcd不去重則為abcda即2個a當做不同的字母看
* @return
*/
public static List<String> split(String target,boolean isDeleteRepeat){
List<String> list=new ArrayList<String>();
for(int i=0;i<target.length();i++){

if(!(isDeleteRepeat&&list.contains(String.valueOf(target.charAt(i))))){
list.add(String.valueOf(target.charAt(i)));}
}
return list;
}
public static List<String> ger(List<String> string){
List<String> list=new ArrayList<String>();
for(int i=1;i<=string.size();i++){
sort(string,new ArrayList<String>(),i);
}
return list;
}
private static void sort(List datas, List target,int num) {
if (target.size() == num) {
for (Object obj : target)
System.out.print(obj);
System.out.println();
return;
}
for (int i = 0; i < datas.size(); i++) {
List newDatas = new ArrayList(datas);
List newTarget = new ArrayList(target);
newTarget.add(newDatas.get(i));
newDatas.remove(i);
sort(newDatas, newTarget,num);
}
}

}

㈥ 關於各種排列組合java演算法實現方法

一 利用二進制狀態法求排列組合 此種方法比較容易懂 但是運行喊隱頌效率不高 小數據排列組合可以使用

復制代碼 代碼如下: import java util Arrays;

//利用二進制演算法進行全排列 //count : //count :

public class test { public static void main(String[] args) { long start=System currentTimeMillis(); count (); long end=System currentTimeMillis(); System out println(end start); } private static void count (){ int[] num=new int []{ }; for(int i= ;i<Math pow( );i++){ String str=Integer toString(i ); int sz=str length(); for(int j= ;j< sz;j++){ str=" "+str; } char[] temp=str toCharArray(); Arrays sort(temp); String gl=new String(temp); if(!gl equals(" ")){ continue; } String result=""; for(int m= ;m<str length();m++){ result+=num[Integer parseInt(str charAt(m)+"")]; } System out println(result); } } public static void count (){ int[] num=new int []{ }; int[] ss=new int []{ }; int[] temp=new int[ ]; while(temp[ ]< ){ temp[temp length ]++; for(int i=temp length ;i> ;i ){ if(temp[i]== ){ temp[i]= ; temp[i ]++; } } int []tt=temp clone(); Arrays sort(tt); if(!Arrays equals(tt ss)){ continue; } String result=""; for(int i= ;i<num length;i++){ result+=num[temp[i]]; } System out println(result); } } }

二 用遞歸的思想攜慧來求排列跟組合 代碼量比較大

復制代碼 代碼如下鄭鄭: package practice;

import java util ArrayList; import java util List;

public class Test {

/** * @param args */ public static void main(String[] args) { // TODO Auto generated method stub Object[] tmp={ }; // ArrayList<Object[]> rs=RandomC(tmp); ArrayList<Object[]> rs=cmn(tmp ); for(int i= ;i<rs size();i++) { // System out print(i+"="); for(int j= ;j<rs get(i) length;j++) { System out print(rs get(i)[j]+" "); } System out println(); } }

// 求一個數組的任意組合 static ArrayList<Object[]> RandomC(Object[] source) { ArrayList<Object[]> result=new ArrayList<Object[]>(); if(source length== ) { result add(source); } else { Object[] psource=new Object[source length ]; for(int i= ;i<psource length;i++) { psource[i]=source[i]; } result=RandomC(psource); int len=result size();//fn組合的長度 result add((new Object[]{source[source length ]})); for(int i= ;i<len;i++) { Object[] tmp=new Object[result get(i) length+ ]; for(int j= ;j<tmp length ;j++) { tmp[j]=result get(i)[j]; } tmp[tmp length ]=source[source length ]; result add(tmp); } } return result; } static ArrayList<Object[]> cmn(Object[] source int n) { ArrayList<Object[]> result=new ArrayList<Object[]>(); if(n== ) { for(int i= ;i<source length;i++) { result add(new Object[]{source[i]}); } } else if(source length==n) { result add(source); } else { Object[] psource=new Object[source length ]; for(int i= ;i<psource length;i++) { psource[i]=source[i]; } result=cmn(psource n); ArrayList<Object[]> tmp=cmn(psource n ); for(int i= ;i<tmp size();i++) { Object[] rs=new Object[n]; for(int j= ;j<n ;j++) { rs[j]=tmp get(i)[j]; } rs[n ]=source[source length ]; result add(rs); } } return result; }

}

三 利用動態規劃的思想求排列和組合

復制代碼 代碼如下: package Acm; //強大的求組合數 public class MainApp { public static void main(String[] args) { int[] num=new int[]{ }; String str=""; //求 個數的組合個數 // count( str num ); // 求 n個數的組合個數 count ( str num); }

private static void count (int i String str int[] num) { if(i==num length){ System out println(str); return; } count (i+ str num); count (i+ str+num[i]+" " num); }

private static void count(int i String str int[] num int n) { if(n== ){ System out println(str); return; } if(i==num length){ return; } count(i+ str+num[i]+" " num n ); count(i+ str num n); } }

下面是求排列

復制代碼 代碼如下: lishixin/Article/program/Java/JSP/201311/20148

㈦ java全排列演算法的解釋，誰能給我比較前面的解釋下全排列演算法啊，看了很多，不是很明白，

排序的作用可以讓一組元數據按照關鍵字進行排序，排序好的可以快速查找相關記錄
【衡量演算法優劣】
①時間復雜度
主要分析關鍵字的比較次數和記錄的移動次數
②空間復雜度
分析排序需要的輔助內存
③穩定性
若記錄A和記錄B的數值相等，排序後的位置不變，則穩定；反之，則不穩定
【分類】
(1)內部排序（常用10種）
①冒泡（交換）
②快速（交換）
③直接選擇（選擇）
④堆排序（選擇）
⑤直接插入（插入）
⑥折半插入（插入）
⑦希爾排序（插入）
⑧歸並排序
⑨桶式排序
(10)基數排序
(2)外部排序
數據量巨大時使用，內存無法保存所有排序數據，需要藉助外部存儲設備，如磁碟等，常用多路歸並排序。
留個郵箱，我把我寫的排序演算法代碼發給你

㈧ java怎麼排列出一組數字所有排列方式

@SuppressWarnings("unchecked")
publicstaticvoidmain(String[]args)throwsException{
		intarr[]={1,2,3};

		for(inti=0;i<3;i++)
			System.out.print(arr[i]);
		System.out.println();

		//開始循環調用字典序演算法,直至全排列排列完畢
		//返回false代敬鏈表排列完畢，返回true代表仍有未排列完的數
		while(fullSort(arr,3));
	}

finalstaticbooleanfullSort(intarr[],intn){
		inti=0,j=0,k=-1,l,temp;

		for(i=0;i<n-1;i++){//找最後的升序的位置
			if(arr[i]<arr[i+1])
				k=i;
		}

		if(k>=0){
			l=-1;

			for(i=0;i<n;i++){//找到最後一個升序且是最大的數的下標
				if(arr[k]<arr[i])
					l=i;
			}

			temp=arr[k];
			arr[k]=arr[l];
			arr[l]=temp;

			for(i=k+1;i<n;i++)//將k+1的元素與末尾模稿仿對調
			{
				j=n-i+k;
				if(i>=j)
					break;

				{
					temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}

		if(k==-1)
			returnfalse;
		for(i=旦纖0;i<n;i++)
			System.out.print(arr[i]);
		System.out.println();

		returntrue;
}