全排列java
㈠ java 求全排列問題，用vector記錄數組怎麼不行，還有數組越界，總是想不到哪兒錯了
看了一下，你把arr存入vector中，其實這時候存的是arr的地址，所以arr發生變化時還是會會發生改變的。修改一下吧。
vrr.add(arr);
改成
int[] out = new int[arr.length];
System.array(arr, 0, out, 0, arr.length);
vrr.add(out);
㈡ java permutation關於全排列的問題
題目寫了下面的方法只是tip，不是一定要遵守的，而他的方法頻繁的創建string，我不喜歡，所以就自己寫了
public class Test {
public static void main(String[] args) {
System.out.println("Input a string: ");
String text = new java.util.Scanner(System.in).next();
permutate(text);
}
static void permutate(String text) {
permutate(text.toCharArray(), 0, text.length());
}
static void permutate(char[] array, int current, int length) {
if (current == length) {
print(array);
return;
}
for (int i = current; i < length; ++i) {
swap(array, current, i);
permutate(array, current + 1, length);
swap(array, current, i);
}
}
static void print(char[] array) {
for (char c : array)
System.out.print(c);
System.out.println();
}
static void swap(char[] array, int first, int second) {
char temp = array[first];
array[first] = array[second];
array[second] = temp;
}
}
㈢ 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
publicclassTest{publicstaticchar[]text={'a','b','c','d','e'};publicstaticvoidmain(String[]args){permutation(text,0,text.length);System.exit(0);}/***全排列輸出**@parama[]要輸出的字元數組*@paramm輸出字元數組的起始位置*@paramn輸出字元數組的長度*/publicstaticvoidpermutation(chara[],intm,intn){inti;chart;if(m<n-1){permutation(a,m+1,n);for(i=m+1;i<n;i++){t=a[m];a[m]=a[i];a[i]=t;permutation(a,m+1,n);t=a[m];a[m]=a[i];a[i]=t;}}else{printResult(a);}}/***輸出指定字元數組**@paramtext將要輸出的字元數組*/publicstaticvoidprintResult(char[]text){for(inti=0;i<text.length;i++){System.out.print(text[i]);}System.out.println();}}
㈤ java全排列遞歸演算法
思路:先有一個起始排列，如1234.從後面掃描，直到找到a[k],a[k]<a[k+1];再從後面掃描，直到找到a[j],這里有 a[k]<a[j]。交換a[k],a[j].再把a[k+1],...a[n-1]排序（從小到大），即得到了一個排列，再循環下去，直到找出所有的排序。用C語言的，參考下: http://user.qzone.qq.com/646203846/infocenter?ptlang=2052
㈥ 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 全排列演算法
遞歸實現，取數字（字元串）中第i個位置的字元，然後將他和剩餘的字元拼接，剩餘的字元串當成有一個全排列的輸入，這樣遞歸下去，只剩一個字元時全排列就是本身。程序中使用set去除了重復的數據，如果需要保留，將set換為list介面即可。
package mytest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
/*
* @date:2012-2-8
* @author:
*
* 輸入一個數字，講輸出 1到這個數字的全排列
*/
public class MyDemo2 {
private static Set<String> SET_STRING = new HashSet<String>();
private static Set<Long> SET_NUM = new HashSet<Long>();
public static void main(String[] args) {
System.out.println("begin ...... ");
testLong(234);
testString("a23");
print(SET_NUM);
print(SET_STRING);
System.out.println("end ...... ");
}
/**
* 測試數字
* @param num
*/
private static void testLong(long num){
long testNum = num;
String[] permutation;
for(long l=0; l<=testNum; l++){
permutation = getAllOrder(String.valueOf(l));
for (int i = 0; i < permutation.length; i++) {
SET_NUM.add(Long.valueOf(permutation[i]));
}
}
}
/**
* 測試字元串
* @param str
*/
private static void testString(String str){
String[] permutation = getAllOrder(str);
for (int i = 0; i < permutation.length; i++) {
SET_STRING.add(permutation[i]);
}
}
private static void print(Set set){
System.out.println("/*****************************************************/");
int i=0;
for(Iterator it = set.iterator(); it.hasNext();){
i++;
if(i%10 == 0){
System.out.println();
}
System.out.print(it.next() + " ");
}
System.out.println();
System.out.println("/*****************************************************/");
}
/**
* 遞歸演算法 全排列 去除重復
* @param str
* @return
*/
private static String[] getAllOrder(String str) {
String [] arrResult = null;
Set<String> set = new HashSet<String>();
if(str.length()>1){
String result = "";
String charXInString;
String remainString;
for (int i = 0; i < str.length(); i++) {
charXInString = str.charAt(i) + "";
remainString = str.substring(0, i)+ str.substring(i + 1, str.length());
for (String element : getAllOrder(remainString)) {
result = charXInString + element;
set.add(result);
}
}
arrResult = set.toArray(new String[set.size()]);
}else{
arrResult = new String[]{str};
}
return arrResult;
}
}
㈧ 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怎麼搞全排列
盡量用遞歸好理解一些,打個斷點
public class Permutation {
public static void permulation(int[] list, int start, int length) {
int i;
if (start == length) {
for (i = 0; i < length; i++)
System.out.print(list[i] + " ");
System.out.println();
} else {
for (i = start; i < length; i++) {
swap(list, start, i);
permulation(list, start + 1, length);
swap(list, start, i);
}
}
}
public static void swap(int[] list, int start, int i) {
int temp;
temp = list[start];
list[start] = list[i];
list[i] = temp;
}
public static void main(String[] args) {
int length = 3;
int start = 0;
int list[] = new int[length];
for (int j = 0; j < length; j++)
list[j] = j + 1;
permulation(list, start, length);
}
}
㈩ 在java環境中用遞歸方法求n個數的無重復全排列，n=3。
給你個思路：
函數內判斷
if (元素個數==2){
列印結果：元素1，元素2；
列印結果：元素2，元素1；
} else {
列印結果：元素1，遞歸本函數(其他元素)；
列印結果：遞歸本函數(其他元素)，元素1；
}