全排列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怎麼搞全排列

盡量用遞歸好理解一些,打個斷點
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全排列遞歸演算法

思路:先有一個起始排列，如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中，用遞歸方法求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 輸入一個字元串,列印出該字元串中字元的所有排列

實現思路：就是輸入字元串後，通過遞歸的方式，循環每個位置和其他位置的字元。

importjava.util.Scanner;

publicclassDemo001{

publicstaticvoidmain(String[]args){
Stringstr="";

Scannerscan=newScanner(System.in);

str=scan.nextLine();

permutation(str.toCharArray(),0);
}

publicstaticvoidpermutation(char[]str,inti){
if(i>=str.length)
return;
if(i==str.length-1){
System.out.println(String.valueOf(str));
}else{
for(intj=i;j<str.length;j++){
chartemp=str[j];
str[j]=str[i];
str[i]=temp;

permutation(str,i+1);

temp=str[j];
str[j]=str[i];
str[i]=temp;
}
}
}
}

㈥ 如何用java輸出一個數組的全排列不能用遞歸，用遞歸的話，很快就內存溢出了！

我覺得吧，你輸出一個全排列用不了多少內存，怎麼就能溢出呢？
首先，遞歸費不了多少內存，應該可以完成任務。
其次，你遞歸都幹了些什麼？別告訴我每層遞歸把數組復制一遍，你把位置遞歸一下就可以了。
如果不喜歡遞歸，可以自己弄個棧，其實差不多，速度略快，空間略小。
如果還是不明白，把全部源碼貼出來看看。