（Java数据结构和算法）递归---三角数字+全排列+二分查找

三角数字

问题：求解三角数字第n项。

public class Main {

	public static void main(String[] args){
		System.out.println(solve(6));
		System.out.println(recursionSolve(6));
	}

	//常规方法求和求解三角数字第n项
	public static int solve(int n){
		int sum = 0;
		for(int i = 1; i <= n; i++){
			sum += i;
		}
		return sum;
	}	

	//递归求解三角数字第n项
	public static int recursionSolve(int n){
		if(n == 1){
			return 1;
		}else{
			return (recursionSolve(n-1) + n);
		}		
	}
}

英文单词全排列（不去重）

思路：对于某英文单词来说，长度为n，先把后n-1个字母做全排列，这就完成了以第一个字母为首的全排列，如果能够完成以该单词所有字母为首的全排列，那就好了！

下面是cat做全排列的例子

（1）需要注意的是每次以某个字母为首的单词全排列做好后，需要把单词复位到该次全排列的初始状态，比如cat以c开头全排列后需要初始为cat，atc以a开头全排列后要初始为atc。这样才能保证每个字母都有机会打头完成对应的一次全排列。
（2）设单词长度是n，一共只需要n个字母分别打头完成全排列，递归层最外面只需要循环n次。

n个字母的全排列转换成n-1个字母的全排列，这就是递归了！直到只有两个字母的排列的时候那就打印输出吧！直到只有一共字母的时候直接返回递归就好了！

import java.io.*;

public class Main {
	public static char[] arrChar = new char[100];
	public static int size;//单词长度
	public static int count = 0;//打印输出的单词编号

	public static void main(String[] args) throws IOException{
		System.out.print("Enter a word:");
		String s = input();
		size = s.length();
		arrChar = s.toCharArray();
		permutation(size);
	}
	//全排列方法
	public static void permutation(int newSize){
		if(newSize == 1){
			return ;
		}
		for(int i = 0; i < newSize; i++){
			permutation(newSize - 1);
			if(newSize == 2){
				print();
			}
			rotate(newSize);
		}
	}
	//打印当前单词
	public static void print(){
		System.out.print(++count+" ");
		for(int i = 0; i < size; i++){
			System.out.print(arrChar[i]);
		}
		System.out.println();
	}
	//当前递归层单词头挪到末尾
	public static void rotate(int newSize){
		int pos = size - newSize;
		char tmp = arrChar[pos];
		for(int i = pos + 1; i < size; i++){
			arrChar[i-1] = arrChar[i];
		}
		arrChar[size-1] = tmp;
	}
	//用BufferedReader方便输入一行
	public static String input() throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		return br.readLine();
	}
	
}

二分查找（递归-分治+非递归）

import java.io.*;

public class Main {
	
	public static void main(String[] args) throws IOException{
		int[] a = {1,2,3,4,5};
		for(int i = 0; i < a.length; i++){
			System.out.print(binarySearch(a, 0, a.length, a[i])+" ");
		}
		System.out.println(binarySearch(a, 0, a.length, 66));	

		for(int i = 0; i < a.length; i++){
			System.out.print(recursionBinarySearch(a, 0, a.length, a[i])+" ");
		}
		System.out.println(recursionBinarySearch(a, 0, a.length, 66));	
	}

	public static int binarySearch(int[] a, int from, int to, int v){
		int l = from;
		int r = to;
		while(l < r){
			int mid = (l+r)/2;
			if(a[mid] == v){
				return mid;
			}else if(a[mid] > v){
				r = mid;
			}else{
				l = mid + 1;
			}			
		}
		return -1;
	}
	//递归分治进行二分
	public static int recursionBinarySearch(int[] a, int from, int to, int v){
		int l = from;
		int r = to;
		while(l < r){
			int mid = (l+r)/2;
			if(a[mid] == v){
				return mid;
			}else if(a[mid] > v){
				return recursionBinarySearch(a, l, mid, v);
			}else{
				return recursionBinarySearch(a, mid+1, r, v);
			}
		}
		return -1;
	}	
}