⑴ java編寫一個方法 找出一個數組里所有數組元素的排列例：輸入{7,2,3} 返回{723,732,327,372,237,273}
import java.util.Arrays;
/**
* 獲得數組全排列的一個實現演算法
*
*/
public class Test {
static String[] array = { "7", "2", "3" };
public static void main(String[] args) {
getAllOrder(0, array.length - 1);
}
public static void getAllOrder(int begin, int end) {
if (begin == end) {
check();
} else {
for (int i = begin; i <= end; i++) {
// 交換數據
swap(begin, i);
getAllOrder(begin + 1, end);
swap(i, begin);
}
}
}
public static void swap(int from, int to) {
// 這里應該加上各種防止無效交換的情況
// 比如位置相同，或者2個位置的數據相同
if (from == to) {
return;
}
String tmp = array[from];
array[from] = array[to];
array[to] = tmp;
}
public static void check() {
// 排列拿到了，可以進行你的判斷了。
System.out.println(Arrays.toString(array));
}
}
記得採納！
⑵ 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 全排列演算法
標准版本：
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 缺項全排列演算法怎麼寫 新人求教！~
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]);
}
}
}
}
⑹ java全排列演算法的解釋，誰能給我比較前面的解釋下全排列演算法啊，看了很多，不是很明白，
排序的作用可以讓一組元數據按照關鍵字進行排序，排序好的可以快速查找相關記錄
【衡量演算法優劣】
①時間復雜度
主要分析關鍵字的比較次數和記錄的移動次數
②空間復雜度
分析排序需要的輔助內存
③穩定性
若記錄A和記錄B的數值相等，排序後的位置不變，則穩定；反之，則不穩定
【分類】
(1)內部排序（常用10種）
①冒泡（交換）
②快速（交換）
③直接選擇（選擇）
④堆排序（選擇）
⑤直接插入（插入）
⑥折半插入（插入）
⑦希爾排序（插入）
⑧歸並排序
⑨桶式排序
(10)基數排序
(2)外部排序
數據量巨大時使用，內存無法保存所有排序數據，需要藉助外部存儲設備，如磁碟等，常用多路歸並排序。
留個郵箱，我把我寫的排序演算法代碼發給你
⑺ 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語言把abcd的全排列演算法（遞歸），改成非遞歸求全排列，遞歸演算法如下： public
最快能想到的就是用四重循環實現。
⑼ 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);
}
}