暴力递归

暴力递归

1.逆序栈(不使用其它数据结构）

package 暴力递归;

import java.util.Stack;

public class ReverseStack {
	public static void reverse(Stack<Integer> stack) {
		if(stack.isEmpty()) {
			return ;
		}
		int i=f(stack);
		reverse(stack);
		stack.push(i);
	}
	public static int f(Stack<Integer> stack) {
		int result=stack.pop();
		if(stack.isEmpty()) {
			return result;
		}else {
			int last=f(stack);
			stack.push(result);
			return last;
		}
	}
}

2.NummberStr

规定1和A对应，2和B对应，3和C对应…那么一个数字字符串比如“111”，就可以转化为“AAA”，“KA”和“AK”。给定一个只有数字字符串组成的字符串str，返回有多少种转化结果。

package 暴力递归;

public class NummberStr {
	public static int process(char[] chs,int i) {
		if(i==chs.length) {
			return 1;
		}
		if(chs[i]=='0') {
			return 0;
		}
		if(chs[i]=='1') {
			int res=process(chs,i+1);
			if(i+1<chs.length) {
				res+=process(chs,i+2);
			}
			return res;
		}
		if(chs[i]=='2') {
			int res=process(chs,i+1);
			if(i+1<chs.length&&(chs[i+1]>='0'&&chs[i+1]<='6')) {
				res+=process(chs,i+2);
			}
			return res;
		}
		return process(chs,i+1);
	}
}

3.CardsInLine

给定一个整型数组arr，代表数值不同的纸牌排成一条线。玩家A和玩家B依次拿走每张纸牌，规定玩家A先拿，玩家B后拿，但是每个玩家每次只能拿走最左或最右的纸牌，玩家A和玩家B都绝顶聪明。请返回获胜者的分数。

package 暴力递归;

public class CardsInLine {
	public static int win1(int[] arr) {
		if(arr==null||arr.length==0){
			return 0;
		}
		return Math.max(f(arr,0,arr.length-1), s(arr,0,arr.length-1));
	}
	public static int f(int[] arr,int i,int j) {
		if(i==j) {
			return arr[i];
		}
		return Math.max(arr[i]+s(arr,i+1,j), arr[j]+s(arr,i,j-1));
	}
	public static int s(int[] arr,int i,int j) {
		if(i==j) {
			return 0;
		}
		return Math.min(f(arr,i+1,j), f(arr,i,j-1));
	}
}

4.AllSubsqueueces

打印一个字符串的全部子序列，包括空字符串。

package 暴力递归;
public class AllSubsqueueces {
	public static void printAllSubsqueuece(String str) {
		char[] chs=str.toCharArray();
		process(chs,0);
	}
	public static void process(char[] str,int i) {
		if(i==str.length) {
			System.out.println(String.valueOf(str));
			return;
		}
		process(str,i+1);
		char temp=str[i];
		str[i]=0;
		process(str,i+1);
		str[i]=temp;
	}
}

5.AllPermutations

全排列

package 暴力递归;

import java.util.ArrayList;

public class AllPermutations {
	public static ArrayList<String> Permutation(String str){
		ArrayList<String> res=new ArrayList<>();
		if(str==null||str.length()==0) {
			return res;
		}
		char[] chs=str.toCharArray();
		process(chs,0,res);
		res.sort(null);
		return res;
	}
	public static void process(char[] chs,int i,ArrayList<String> res) {
		if(i==chs.length) {
			res.add(String.valueOf(chs));
		}
		boolean[] visit=new boolean[26];
		for(int j=i;j<chs.length;j++) {
			if(!visit[chs[j]-'a']) {      //防止出现重复的排列结果
				visit[chs[j]-'a']=true;
				swap(chs,i,j);
				process(chs,i+1,res);
				swap(chs,i,j);
			}
		}
	}
	public static void swap(char[] chs,int i,int j) {
		char temp=chs[i];
		chs[i]=chs[j];
		chs[j]=temp;
	}
}