『壹』 java如何實現対一數組全排列，
事實上，就是對數組下標的全排列
第2，就是從一個開始去找不是自己位置的相同字元
『貳』 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 全排列演算法
標准版本：
public static void main(String[] args) {
List<Integer[]> resultList = new LinkedList<Integer[]>();
construct(new int[]{0, 1}, new LinkedList<Integer>(), 4, resultList);
for (Integer[] result : resultList) {
System.out.println(Arrays.toString(result));
}
}
private static void construct(int[] elements, List<Integer> pre, int length, List<Integer[]> resultList) {
if (pre.size() == length) {
resultList.add(pre.toArray(new Integer[0]));
} else {
for (int e : elements) {
List<Integer> newPre = new LinkedList<Integer>(pre);
newPre.add(e);
construct(elements, newPre, length, resultList);
}
}
}
投機取巧版本：
public static void main(String[] args) {
int length = 4;
for (int i = 0, max = (int) Math.pow(2, length); i < max; i++) {
int[] result = new int[length];
int num = i;
for (int j = length - 1; j >= 0; j--) {
result[j] = num & 1;
num = num >> 1;
}
System.out.println(Arrays.toString(result));
}
}
『肆』 java 全排列演算法;
= =~思路什麼的...用遞歸吧：
package mon_11;
import java.util.HashSet;
public class ArrangeAll {
private static HashSet<String> set = new HashSet<String>();
public static void arrangeAll(String s) {
put(new StringBuilder(s), new StringBuilder());
}
static void put(StringBuilder s1, StringBuilder s2) {
if (s1.length() == 0)set.add(s2.toString());
for (int i = 0; i < s1.length(); i++) {
put(new StringBuilder(s1).deleteCharAt(i),new StringBuilder(s2).append(s1.charAt(i)));
}
}
public static void main(String[] args) {
arrangeAll("abcd");
System.out.println(set);
}
}
----
輸出：
[dcab, acdb, acbd, bcda, bdca, bdac, dbca, bacd, cabd, cdba, cdab, badc, dabc, cadb, dbac, bcad, dacb, cbda, cbad, adbc, adcb, abcd, abdc, dcba]
『伍』 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的排序演算法有哪些
排序： 插入，冒泡，選擇，Shell,快速排序
『柒』 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全排列演算法的解釋，誰能給我比較前面的解釋下全排列演算法啊，看了很多，不是很明白，
排序的作用可以讓一組元數據按照關鍵字進行排序，排序好的可以快速查找相關記錄
【衡量演算法優劣】
①時間復雜度
主要分析關鍵字的比較次數和記錄的移動次數
②空間復雜度
分析排序需要的輔助內存
③穩定性
若記錄A和記錄B的數值相等，排序後的位置不變，則穩定；反之，則不穩定
【分類】
(1)內部排序（常用10種）
①冒泡（交換）
②快速（交換）
③直接選擇（選擇）
④堆排序（選擇）
⑤直接插入（插入）
⑥折半插入（插入）
⑦希爾排序（插入）
⑧歸並排序
⑨桶式排序
(10)基數排序
(2)外部排序
數據量巨大時使用，內存無法保存所有排序數據，需要藉助外部存儲設備，如磁碟等，常用多路歸並排序。
留個郵箱，我把我寫的排序演算法代碼發給你
『玖』 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 缺項全排列演算法怎麼寫 新人求教！~
public static void main(String[] args) {
System.out.println(KeyEvent.VK_UP);
String a = "1234";
char[] arry = a.toCharArray();
for (int i = 0; i < arry.length; i++) {
System.out.println(arry[i]);
}
for (int i = 0; i < arry.length; i++) {
for (int j = i + 1; j < arry.length; j++) {
System.out.println(arry[i] + "" + arry[j]);
}
}
for (int i = 0; i < arry.length; i++) {
for (int j = i + 1; j < arry.length; j++) {
for (int z = j + 1; z < arry.length; z++) {
System.out.println(arry[i] + "" + arry[j] + "" + arry[z]);
}
}
}
}