递归 --与三角数字,阶乘,变位字,汉诺塔问题,递归的二分查找法,归并排序

1)三角数字

数列1,3,6,10,15,21,... 这个数列中的第n项是由第n-1项加n得到的.

int triangle(int n){

int total=0;

while(n>0){

total+=n--;

}

return total;

}

2)变位字

一个单词cat的全排列,会形成多少个不同的单词,打印出它们.

1全排列最右连的n-1个字母

2 轮换所有n个字母

3 重复以上步聚n次

public class Anagram {

private static  char[] words;
private static int count;

public static void main(String[] args) {
if(args.length<1) {
System.out.println("请输入需要打印变位字的单词");
System.exit(0);
}
words=args[0].toCharArray();
count=0;
doAnagram(words.length);
}

private static void doAnagram(int newSize) {
if(newSize==1)
return;
for(int j=0; j<newSize; j++) {
doAnagram(newSize-1);
if(newSize==2)
displayWord();
rotate(newSize);
}
}

private static void rotate(int newSize) {
int j=words.length-newSize;
char temp=words[j];
for(; j+1<words.length; j++) {
words[j]=words[j+1];
}
words[j]=temp;
}

private static void displayWord() {
System.out.print(++count+":");
for(int j=0; j<words.length; j++) {
System.out.print(words[j]);
}
System.out.print("   ");
if(count%5==0)
System.out.println("");
}

}

3 汉诺塔问题

假设想要把n个盘子从源塔座(S)移动到目标塔座(D)上,有一个可以使用的中介塔座(I)

1 从塔座S移动包含n-1个盘子到塔座I上

2 从塔座S移动剩余那个盘子到塔座D上

3 从塔座I移动n-1个盘子到塔座D上

这样移动n个盘子的问题变成了移动n-1个盘子的问题.

4 归并排序

简单排序都要用O(N^2)时间,归并排序只要O(N*logN)时间

import java.util.Random;
public class MergeSort {

public static void main(String[] args) {
int size=15;
Random ran = new Random();
int[] sort = new int[size];
for(int i = 0 ; i < size ; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for(int i : sort) {
System.out.print(i+" ");
}
int[] workSpace=new int[size];
recMergeSort(workSpace,sort,0,size-1);
System.out.println();
System.out.print("排序后的数组为");
for(int i : sort) {
System.out.print(i+" ");
}
}

/**
* 归并排序,时间复杂度O(N*LogN),空间复杂度,需要一个和原数组一样大小的空间O(N)
* @param sort
*/

private static void recMergeSort(int[] workSpace,int[] sort,int lowerBound,int upperBound) {
if(lowerBound==upperBound)
return;
else {
int mid=(lowerBound+upperBound)/2;
recMergeSort(workSpace,sort,lowerBound,mid);
recMergeSort(workSpace,sort,mid+1,upperBound);
merge(workSpace,sort,lowerBound,mid+1,upperBound);
}
}

private static void merge(int[] workSpace,int[] sort,int lowPtr,int highPtr,int upperBound) {
int j=0;
int lowerBound=lowPtr;
int mid=highPtr-1;
int n=upperBound-lowerBound+1;
while(lowPtr<=mid&&highPtr<=upperBound) {
if(sort[lowPtr]<sort[highPtr])
workSpace[j++]=sort[lowPtr++];
else
workSpace[j++]=sort[highPtr++];
}
while(lowPtr<=mid)
workSpace[j++]=sort[lowPtr++];
while(highPtr<=upperBound)
workSpace[j++]=sort[highPtr++];
for(j=0; j<n; j++) {
sort[lowerBound+j]=workSpace[j];
}
}

}

5)表插入排序

先把数据插入到一个有序链表中,然后清空数组,再把数据复制回数组,插入第N个数据平均比较n/2次,

数据序数 平均比较次数

1 0

2 1

3 (1+2)/2

4 (1+2+3)/3

5 (1+2+3+4)/4

....

N (1+2+3+4+N-1)/n =n(n-1)/(2*n)= (n-1)/2

-----------------------------------------------------------------------------------

总平均比较次数(0/2+1/2+2/2+..+(n-1)/2)= 0.5*(n-1)*n*0.5=N^2/4

总复制次数2N,优于直接插入排序的 平均比较次数n^2/2,复制次数n^2/2,但空间占用是O(n)