全排列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输出一个数组的全排列不能用递归，用递归的话，很快就内存溢出了！

我觉得吧，你输出一个全排列用不了多少内存，怎么就能溢出呢？
首先，递归费不了多少内存，应该可以完成任务。
其次，你递归都干了些什么？别告诉我每层递归把数组复制一遍，你把位置递归一下就可以了。
如果不喜欢递归，可以自己弄个栈，其实差不多，速度略快，空间略小。
如果还是不明白，把全部源码贴出来看看。