java遞歸排序

『壹』 如何使用java實現一個簡單的遞歸程序

【答案】：這是一個排列的例子，它胡亂所做的工作是將輸入的一個字元串中的所有元素進行排序並輸出，例如：你給出的參數是」abc」 則程序會輸出： abc acb bac bca cab cba a.演算法的出口在於：low=high也就是現在給出的排列元素只有一個時。 b.演算法的逼近過程：先確臘游定排列的第一位元素，也就是循環中i所代表的元素， 然後low+1開始褲局檔減少排列元素，如此下去，直到low=high public class Foo {
public static void main(String[] args) {
permute(「abc」);
}
public static void permute(String str) {
char[] strArray = str.toCharArray();
permute(strArray, 0, strArray.length – 1);
}
public static void permute(char[] list, int low, int high) {
int i;
if (low == high) {
String cout = 「」;
for (i = 0; i <= high; i++)
cout += list[i];
System.out.println(cout);
} else {
for (i = low; i <= high; i++) {
char temp = list[low];
list[low] = list[i];
list[i] = temp;
permute(list, low + 1, high);
temp = list[low];
list[low] = list[i];
list[i] = temp;
}
}
}
}

『貳』 java 定義了5個數字的數組，顯示輸出所有的排列組合

importjava.util.ArrayList;
importjava.util.List;
publicclassPermAComb{
staticList<int[]>allSorts=newArrayList<int[]>();

publicstaticvoidpermutation(int[]nums,intstart,intend){
if(start==end){//當只要求對數組中一個數字進行全排列時，只要就按該數組輸出即可
int[]newNums=newint[nums.length];//為新的排列創建一個數組容器
for(inti=0;i<=end;i++){
newNums[i]=nums[i];
}
allSorts.add(newNums);//將新的排列組合存放起來
}else{
for(inti=start;i<=end;i++){
inttemp=nums[start];//交換數組第一個元素與後續的元素
nums[start]=nums[i];
nums[i]=temp;
permutation(nums,start+1,end);//後續元素遞歸全排列
nums[i]=nums[start];//將交換後的數組還原
nums[start]=temp;
}
}
}

publicstaticvoidmain(String[]args){
int[]numArray={1,2,3,4,5,6};
permutation(numArray,0,numArray.length-1);
int[][]a=newint[allSorts.size()][];//你要的二維數組a
allSorts.toArray(a);

//列印驗證
for(inti=0;i<a.length;i++){
int[]nums=a[i];
for(intj=0;j<nums.length;j++){
System.out.print(nums[j]);
}
System.out.println();
}
System.out.println(a.length);
}
}

採納吧

『叄』 JAVA程序經常用到「遞歸」,「遞歸」的基本思想是

遞歸的核心思想是分解。把一個很復雜的問題使用同一個策略將其分解為較簡單的問題，如果這個的問題仍然不能解決則再次分解，直到問題能被直接處理為止。
比如求 1+1/2+1/3+...+1/n的和，如果按照我們正常的思維，就會使用一個循環，把所有的表示式的值加起來，這是最直接的辦法。如果使用遞歸的思維，過程就是這樣的，要求1+1/2+1/3+...+1/n的值，可以先求s1=1+1/2+1/3+...+1/(n-1)的值，再用s1加上1/n就是所求的值，而求s1的過程又可以使用上面的分解策略繼續分解，最終分解到求1+1/2的值，而這個問題簡單到我們可以直接解決，自此問題得到解決。
遞歸強調的分治的策略，再舉個例子，有一種排序演算法叫歸並排序，其思想是這樣的：要對一個無序的數組進行排序，可以將這個數組分解為2個小數組，然後對這兩個數組分別排序，再把排好序的兩個數組合並。而這一過程中只有「對兩個數組分別排序」不是我們能解決的，但是這個問題可以使用上面的策略進行再次的分解，最後這個問題就被分解到對2個元素的數組進行排序，而這個問題簡單到我們可以直接處理。
上面提到的分解的策略，或者說演算法，抽象出來就是我們的函數，因為在這個過程中我們要不同的使用這個策略來不斷的分解問題，所以代碼上就體現為這個函數會不斷的調用自身。還有一點，並不是所有的遞歸都是可以實現的，或者說有意義的。如果在分解的過程中，問題最終不能分解到一個可以直接解決的問題，則這個過程是沒有意義，也就是無限的循環。
具體的代碼都不貼了，有興趣可以網路看看。

『肆』 java演算法有哪些分別

您好：

java中的演算法，常見的有：遞歸、迭代、查找、排序（包含冒泡排序、選擇排序、插入排序、快速排序四種） 等，演算法有很多，一般數據結構中涉及到的都可以用java語言實現。

舉幾個例子：

1.遞歸的例子：

不一一舉例，僅供參考！

『伍』 java二分法查找的遞歸演算法怎麼實現

publicclass二分法遞歸查找{
	publicstaticvoidmain(String[]args){

		//定義數組,注意,二分查找數組必須是有序的數組!
		int[]arr={1,3,5,7,9,11,13,15,17};
		
		//接受查找後的返回值:索引值,如果沒有則是-1;
		//測試查找元素:9
		inta=binary(arr,9,0,arr.length-1);
		System.out.println("被查找數字索引位置在:"+a);
	}
	//參數列表依次為:被查找的數組,查找的數字,頭索引,尾索引!
	publicstaticintbinary(int[]arr,intkey,intstar,intend)//遞歸
	{
		//每次進來創建,中間索引值!
		intmid=(star+end)/2;
		//如果被查找數小於頭,或者尾,或者頭索引大於尾索引,則說明無該數,返回-1;
		if(key<arr[star]||key>arr[end]||star>end){
			return-1;
		}
		//如果中間值小於被查找數,則重新定義頭索引移至中間+1位置,篩選掉一半數字!
		if(arr[mid]<key){
			//開始遞歸!
			returnbinary(arr,key,mid+1,end);
			//否則如果中間值大於被查找數,則重新尾索引移至中間-1位置,篩選掉一半數字!
		}elseif(arr[mid]>key){
			//開始遞歸!
			returnbinary(arr,key,star,mid-1);
		}else{
			//否者就是找到了,返回該索引!
			returnmid;
		}
	}
}