全排列的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的排序演算法有哪些
java的排序大的分類可以分為兩種：內排序和外排序。在排序過程中，全部記錄存放在內存，則稱為內排序，如果排序過程中需要使用外存，則稱為外排序。下面講的排序都是屬於內排序。
1.插入排序：直接插入排序、二分法插入排序、希爾排序。
2.選擇排序：簡單選擇排序、堆排序。
3.交換排序：冒泡排序、快速排序。
4.歸並排序
5.基數排序
㈣ 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 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 全排列演算法
標准版本：
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語言把abcd的全排列演算法（遞歸），改成非遞歸求全排列，遞歸演算法如下： public
最快能想到的就是用四重循環實現。
㈧ 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數組的全排列，裡面布爾類型的數組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為未使用狀態
}
}