递归 入门

以前在面试的时候偶尔遇到递归方面的程序题，最近有个朋友找工作也遇到了，看来递归在面试过程中也经常用到。递归最有名的就是斐波那契（Fibonacci）数列和汉诺塔，概念就不说了，简单的说就是自己调用自己。直接看程序，

在网上找了几个题：

      1.求数组中的最大数

package com.wayne.recursion;

/**
 * 采用递归（recursion）求数组中的最大数
 * 
 * @author Administrator
 */
public class RecursionArrayMaxValue {
	public static int getMaxValue(int arr[], int i) {
		if (i == 1) {
			return arr[i];
		} else {
			if (arr[i - 1] >= arr[i - 2]) {
				arr[i - 2] = arr[i - 1];
				return getMaxValue(arr, i - 1);
			}
			return getMaxValue(arr, i - 1);
		}
	}
}

 

package com.wayne.recursion;

import static org.junit.Assert.*;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class RecursionArrayMaxValueTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

	@Test
	public void testGetMaxValue() {
		int arr[] = { 3, 23, 43, 23, 12, 23, 23, 43, 23, 1, 3, 54, 54 };
		int max = RecursionArrayMaxValue.getMaxValue(arr, arr.length);
		assertEquals(54, max);
	}

}

 
　　2.1+2+3+...+n

package com.wayne.recursion;

/**
 * 采用递归（recursion）求1+2+3+...+n值
 * 
 * @author Administrator
 * 
 */
public class RecursionSum {
	public static int getSum(int n) {
		if (n == 1) {
			return 1;
		}
		return n + getSum(n - 1);
	}
}

 

package com.wayne.recursion;

import static org.junit.Assert.*;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class RecursionSumTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

	@Test
	public void testGetSum() {
		int sum = RecursionSum.getSum(5);
		assertEquals(15, sum);
	}

}

 
　　3.求n个整数的积

package com.wayne.recursion;

/**
 * 采用递归（recursion）求n个整数的积
 * 
 * @author Administrator
 */
public class RecursionProduct {
	public static int getProduct(int arr[], int i) {
		if (i == 2) {
			return arr[1] * arr[0];
		}
		if (i == 1) {
			return arr[0];
		}
		arr[i - 2] = arr[i - 1] * arr[i - 2];
		return getProduct(arr, i - 1);
	}
}

 

package com.wayne.recursion;

import static org.junit.Assert.*;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class RecusionProductTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

	@Test
	public void testGetProduct() {
		int arr[] = { 3, 4, 5, 3, 2 };
		assertEquals(360, RecursionProduct.getProduct(arr, arr.length));
	}

}

 

当做完几个递归后就会发现用程序实现递归找到几个入口就好写了：

 

1.寻找特定规律

2.确定边界(终了)条件

3.注意返回结果的控制

不过对于很多复杂的问题将其简单化用递归来设计还是挺有难度的。对于我这样的菜鸟级的就只能慢慢爬了。