领题，领币，给需要的童鞋 - 黑马程序员技术交流社区

public class Demo
{
static char operator[] = new char[8];
static char expre[] = new char[]
{ '1', '+', '2', '+', '3', '+', '4', '+', '5', '+', '6', '+', '7', '+',
'8', '+', '9' };
public static void main(String[] args)
{
fun(0);
}
public static void fun(int n)
{
if (8 == n)
handle(100);
else
{
/*
这里的递归原理是：
1.注意观察我标记的断点位置，n从0-7断点以下的程序都是没有机会执行的。
2.当n=7的时候程序会从断点开始继续往下运行，然后是n=6（3*3种情况）,5（3*3*3种情况）,4,3,,,0（3的8次方）
3.这个复杂递归的原理在于实现3的8次方种可能性。
4.这里用*号代替空，不要以为是错的。。。。
*/
operator[n] = '+';
expre[n * 2 + 1] = operator[n];
fun(n + 1);//-------------断点----------------
operator[n] = '-';
expre[n * 2 + 1] = operator[n];
fun(n + 1);
operator[n] = '*';
expre[n * 2 + 1] = operator[n];
fun(n + 1);
}
}
private static void handle(int n)
{
StringBuffer sb = new StringBuffer();
// 将乘法替换成空格
for (int i = 0; i < expre.length; i++)
if (expre[i] != '*')
sb.append(expre[i]);
String expression = sb.toString();
// 分割等式, 先根据运算符分割
String[] num = expression.split("[+-]");
// 根据数字,分割出其中的运算符
String[] operator = expression.split("[1-9]");
int sum = Integer.parseInt(num[0]);
for (int i = 0, j = 1; i < operator.length; i++)
{
if (operator[i].equals("+"))
sum += Integer.parseInt(num[j++]);
if (operator[i].equals("-"))
sum -= Integer.parseInt(num[j++]);
}
if (sum == n)
System.out.println(expression + "=" + n);
}
}

复制代码

package test;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collections;
import java.util.TreeSet;
class Test2 {
/*
* 1.遍历出斐波那契数列前100个数 2.任意定义一个数组，用for,while和递归三种方式求和
* 3.对于任意一个给定数组比如【1,23,56,7】,给出用数组元素能够拼出的最大整数，这里的结果为756231
* 4.1,2,3,4,5,6,7,8,9这9个数的排列顺序不能动，元素之间可以添加加号或者减号或者什么都不加，
* 但要保证最终的结果为100；遍历出所有的可能性。
* 5.编写一个交错排列元素的函数，比如["2","5","7"]和["a","c","e"]得到结果[2,a,5,c,7,e],bingo~
*/
public static void main(String[] args) {
test1();
test2();
test3();
test4();
test5();
}
public static void test5() {
String[] arr1={"2","5","7"};
String[] arr2={"a","c","e"};
String[] result=staggeringArray(arr1,arr2);
System.out.println(Arrays.toString(result));
}
public static String[] staggeringArray(String[] arr1, String[] arr2) {
String[] result=new String[arr1.length+arr2.length];
int min=0;
String[] maxArr=null;
if(arr1.length>arr2.length){
min=arr2.length;
maxArr=arr1;
}else{
min=arr1.length;
maxArr=arr2;
}
for(int i=0;i<min;i++){
result[2*i]=arr1[i];
result[2*i+1]=arr2[i];
}
int index=2*min;
for(int i=min;i<maxArr.length;i++)
result[index++]=maxArr[i];
return result;
}
//4 1,2,3,4,5,6,7,8,9这9个数的排列顺序不能动，
//元素之间可以添加加号或者减号或者什么都不加但要保证最终的结果为100；遍历出所有的可能性。
public static void test4() {
combine(new StringBuilder("1"),1);
}
public static void combine(StringBuilder result,int index)
{
if(index == 9) {
cal(result.toString());
return;
}
//分三种情况，分别为插入“+”，“-”和不插入任何符号
for(int i = 0;i < 3;i++) {
switch(i){
//假设i=0时插入“+”
case 0:
result.append("+");
result.append(index + 1);
combine(result,index + 1);
result.delete(result.length() - 2,result.length());
break;
//假设i=1时插入“-”
case 1:
result.append("-");
result.append(index + 1);
combine(result,index + 1);
result.delete(result.length() - 2,result.length());
break;
//假设i=2时什么都不插入
case 2:
result.append(index + 1);
combine(result,index + 1);
result.deleteCharAt(result.length() - 1);
break;
}
}
}
public static void cal(String str) {
int sum = 0;
String[] num = str.split("[+|-]"); //将串中的各个数抽取出来
String[] code = str.split("\\d"); //得到各个运算符
sum += Integer.valueOf(num[0]); //先将第一个数加上
int n = 0;
for(int i = 0;i < code.length;i++) {
if(code[i].equals("+"))
sum += Integer.valueOf(num[++n]);
if(code[i].equals("-"))
sum -= Integer.valueOf(num[++n]);
}
if(sum == 100)
System.out.println(str);
}
// 3.对于任意一个给定数组比如【1,23,56,7】,给出用数组元素能够拼出的最大整数，这里的结果为756231
public static void test3() {
int[] arr = { 1, 23, 56, 7 };
String result = getMaxNumString(arr);
System.out.println(result);
}
public static String getMaxNumString(int[] arr) {
TreeSet<String> set=new TreeSet<String>(Collections.reverseOrder());
String result="";
for(int i:arr){
set.add(String.valueOf(i));
}
for(String str:set){
result+=str;
}
return result;
}
public static void test2() {
int[] arr = { 1, 2, 3, 4 };
int result1 = forAdd(arr);
int result2 = whileAdd(arr);
int result3 = diguiAdd(arr);
System.out.println(result1 + ":" + result2 + ":" + result3);
}
private static int diguiAdd(int[] arr) {
return diguiAdd(arr, arr.length-1);
}
private static int diguiAdd(int[] arr, int index) {
if (index == 0)
return arr[0];
return arr[index] + diguiAdd(arr, index - 1);
}
private static int whileAdd(int[] arr) {
int sum = 0;
int index = 0;
while (index != arr.length) {
sum += arr[index];
index++;
}
return sum;
}
private static int forAdd(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++)
sum += arr[i];
return sum;
}
public static void test1() {
BigInteger[] arr = new BigInteger[100];
arr[0] = new BigInteger("0");
arr[1] = new BigInteger("1");
for (int i = 2; i < arr.length; i++) {
arr[i] = arr[i - 1].add(arr[i - 2]);
}
System.out.println(Arrays.toString(arr));
}
}

复制代码

package test;
public class C3 {
// 遍历所有情况
public static void fun(String v, int n) {
if(n==9){ // 修改完最后一位符号时输出
check(v);
return;
}
// 递归向后修改，数字变为数字加符号
fun(v.replace(String.valueOf(n), n+"+"),n+1);
fun(v.replace(String.valueOf(n), n+"-"),n+1);
fun(v,n+1);
}
public static void check(String str){
String[] s = str.split("[+|-]"); // 得到全部数字
String sign = str.replaceAll("\\d*",""); // 得到全部符号（+-）
int sum = Integer.parseInt(s[0]); // 把第一个数字给sum
for(int i=0;i<s.length-1;i++){
switch(sign.charAt(i)){
case '+':
sum += Integer.parseInt(s[i+1]);
break;
case '-':
sum -= Integer.parseInt(s[i+1]);
break;
}
}
if(sum==100){ // 符合条件输出
System.out.println(str);
}
}
public static void main(String[] args){
String str = "123456789";
fun(str,1); // 调用函数，从1开始修改
}
}

复制代码

public class feibonaqi {
/**
* 1.遍历出斐波那契数列前100个数
*/
public static void main(String[] args) {
method_1(100);
}
public static int method(int i) {
// 前两项不在通项范围
if (i == 1 || i == 2) {
// 前两项返回自身的值1
return 1;
} else {
// 此数列从第三项开始每一项的值是前两项的和（规律）
// 递归算法，在此方法之内调用本方法
return method(i - 1) + method(i - 2);
}
}
public static void method_1(int n) {
// 此处i控制的是角标，n控制的是项数
for (int i = 1; i <= n; i++) {
System.out.println("这是斐波那契数列第" + i + "项");
// 对根据项数对每一项进行遍历输出
System.out.println(method(i));
}
}
}

复制代码

/**
* 2.任意定义一个数组，用for,while和递归三种方式求和
*/
@SuppressWarnings("serial")
public class AddDemo
{
static int sum = 0;
static int flag =0;
public static void main(String[] args)
{
int[] num = {4,6,8,2,10};
//用for求和
forAdd(num);
//用while求和
whileAdd(num);
//用递归算法求和
recursionAdd(num);
System.out.println("recursionSum="+sum);
}
//用for循环求任意数组元素的和
public static void forAdd(int[] num)
{
//初始化sum
int sum = 0;
//遍历输出数组元素
for(int i=0;i<num.length;i++)
{
//求和
sum = sum +num[i];
}
System.out.println("forSum="+sum);
}
//用while循环求任意数组元素的和
public static void whileAdd(int[] num)
{
//定义整型变量sum,i，并且初始化为0
int sum = 0;
int i = 0;
//遍历输出数组元素
while(i<num.length)
{
//求和
sum = sum +num[i];
//循环条件
i++;
}
System.out.println("whileSum="+sum);
}
//用递归求任意数组元素的和
public static void recursionAdd(int[] num)
{
//求和
sum = sum +num[flag];
//根据标记flag的变化，来取数组内元素
flag++;
//递归结束条件
if(flag<num.length)
{
//递归算法
recursionAdd(num);
}
}
}

复制代码

/**
* 3.对于任意一个给定数组比如【1,23,56,7】,给出用数组元素能够拼出的最大整数，这里的结果为756231
*/
public class FindMax {
public static void main(String[] args) {
//定义int型数组
int[] arr = {1,23,56,7};
//调用拼数方法
method(arr);
}
@SuppressWarnings("unchecked")
//拼数方法
public static void method(int[] arr)
{
String str=null;
//声明StringBuffer容器
StringBuffer sb = new StringBuffer();
//遍历数组
for(int in : arr)
{
//将遍历后的元素添加到StringBuffer容器中,并且用空格分割
str = sb.append(in+" ").toString();//toString()方法将容器中元素转换为字符串类型
}
//分割字符串
String[] str1 = str.split(" ");
//声明TreeSet集合并且使集合具有可比较性
TreeSet ts = new TreeSet(new MyCompare());
//遍历字符串，在其后加0使其达到相同的长度
for(int i=0;i<str1.length;i++)
{
if(str1[i].length()==1)
{
str1[i]=str1[i]+"0";
}
//将具有相同长度的字符串添加到TreeSet集合中，方便比较
ts.add(str1[i]);
}
//对TreeSet集合进行遍历
Iterator it = ts.iterator();
while(it.hasNext())
{
String s3 = (String) it.next();
//去掉遍历后字符串中存在的0
String s4=s3.replaceAll("0", "");
//打印结果
System.out.print(s4);
}
}
}
@SuppressWarnings("unchecked")
//自定义比较器
class MyCompare implements Comparator
{
public int compare(Object o1, Object o2) {
String s1 = (String) o1;
String s2 = (String) o2;
if(Integer.parseInt(s1)> Integer.parseInt(s2))
{
return -1;
}
return 0;
}
}

复制代码

public class CrossDemo {
/**
* 5.编写一个交错排列元素的函数，比如["2","5","7"]和["a","c","e"]得到结果[2,a,5,c,7,e]
*/
public static void main(String[] args) {
String[] s1={"2","5","7"};
String[] s2={"a","c","e"};
crossMethod(s1,s2);
}
public static void crossMethod(String[] s1,String[] s2)
{
System.out.print("[");
for(int i= 0;i<s1.length;i++)
{
System.out.print(s1[i]+","+s2[i]+",");
}
System.out.print("]");
}
}

复制代码