剑指Offer编程【Java版】 T6-10

六.旋转数组的最小数字

题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

思路：利用二分法，找到中间的数，然后和最左边的值进行比较，若大于最左边的数，则最左边从mid开始，若小于最右边值，则最右边从mid开始。若左中右三值相等，则取mid前后值中较小的数。

/*
1、left < right  ----即旋转了0个元素  -->直接返回left
2、left > right 与中间值进行比较，使用二分法【注意：二分法只支持无重复数组，且有序】
3、特殊情况：left == right == mid  例如：11011111   ----只能使用顺序查找-->即遍历

*/
public class Solution{
	public int minNumberInRotateArray(int [] array) {
        if (array == null || array.length == 0) {//判断是否合法
        	return 0;
        }
        int left = 0;
        int right = array.length - 1;
        int mid = 0;	//因为返回值需要使用，则在while外面赋初值

        while (array[left] >= array[right]) {	//3 4 5 1 2    &  1 1 1 0 1 1    &   3 2
            if(right - left <= 1) {	//只有两个元素，互换位置，则指向right
                mid = right;
                break;
            }
            mid = (left + right)/2;
            if (array[left] == array[mid] && array[mid] == array[right]) {	//特殊情况：如：1 1 0 1 1 1 -->旋转后的
                if (array[left+1] != array[right-1]) {	//向中间查找（循环）
                  left++;
                  right--;
                }
            } else {
              if (array[left] <= array[mid]) {//二分法：先比较left
                  left = mid;
              } else {
                  right = mid;
              }
            }
        }
        return array[mid];
    }
}

 

七.斐波那契数列【递归的效率低，使用循环】

 

题目描述：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

n<=39

斐波那契数列：1  1  2  3  5  8  13  21 ......前两个是1，后面的依次是前两个相加

 

//方法一：递归      效率很低的解法   O(n^2)

public class Solution {
    public int Fibonacci(int n) {
        if(n==1 || n==2){
            return 1;
        }else if(n>0 && n<=39){
            return Fibonacci(n-1)+Fibonacci(n-2);
        }else{
            return 0;
        }
    }
}

// 方法二：循环  ----推荐     时间复杂度为O(n)
public class Solution {
    public int Fibonacci(int n) {
		if(n<1) {
			return 0;
		}
		if(n==1 || n==2) {
			return 1;
		}
		int res = 1;
		int pre = 1;
		int tmp = 0;
		for(int i=3;i<=n;i++) {
			tmp = res;
			res = res + pre;
			pre = tmp;
		}
		return res;
	}

八、跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

分析：（递归方法）与斐波那契数列相同，跳台阶有两种方法，1阶或者2阶，当只有1个台阶时，一种跳法，2个台阶，两种跳法。每次都只有两种选择。如果第一次跳1个，则剩下的(n-1)个台阶跳法是f(n-1)，如果第一次跳2个，则剩下的(n-2)个台阶跳法是f(n-2)，则所以f(n) = f(n-1) + f(n-2).

 

public class Solution {
    public int JumpFloor(int target) {
        if(target <= 0){
            return 0;
        }
        if(target == 1){
            return 1;
        }
        if(target == 2){
            return 2;
        }
      //第一次有两种选择，根据不同的选择，继续跳下一步，下一步依然是有两种选择
        return JumpFloor(target-1) + JumpFloor(target-2);
    }
}

九、变态跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

因为f(1) = 1 一个台阶只有一种跳法

 

// 数学归纳法

	public int JumpFloorII(int target) {
		int result = 1;

		if (target <= 0) {
			return 0;
		} else if (target == 1) {
			return 1;
		} else {
			for (int i = 1; i < target; i++) {
				result *= 2;
			}
			return result;
		}
	}

/**
 * 	递归方法
 * 
 * 	f(n) = 2 * f(n-1)
 * 
 * @author Mona
 *
 */
public class ManyTests {
	public int JumpFloorII(int target) {
		if(target <= 0) {
			return -1;
		}
		if(target == 1) {
			return 1;
		}
		return 2*JumpFloorII(target-1);
	}
}

十、矩形覆盖

题目描述：我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

【以下分析来自牛客网-->分析的很全面】

（1）当 n < 1时，显然不需要用2*1块覆盖，按照题目提示应该返回 0。

（2）当 n = 1时，只存在一种情况。

 

（3）当 n = 2时，存在两种情况。

 

（4）当 n = 3时，明显感觉到如果没有章法，思维难度比之前提升挺多的。

 

链接：https://www.nowcoder.com/questionTerminal/72a5a919508a4251859fb2cfb987a0e6

来源：牛客网

... 尝试归纳，本质上 n 覆盖方法种类都是对 n - 1 时的扩展。

可以明确，n 时必定有 n-1时原来方式与2*1的方块结合。也就是说, f(n) = f(n-1) + ?(暂时无法判断)。

（4）如果我们现在归纳 n = 4，应该是什么形式？

4.1）保持原来n = 3时内容，并扩展一个 2*1 方块，形式分别为 “| | | |”、“= | |”、“| = |”

4.2）新增加的2*1 方块与临近的2*1方块组成 2*2结构，然后可以变形成 “=”。于是 n = 4在原来n = 3基础上增加了"| | ="、“= =”。

再自己看看这多出来的两种形式，是不是只比n = 2多了“=”。其实这就是关键点所在...因为，只要2*1或1*2有相同的两个时，就会组成2*2形式，于是就又可以变形了。

所以，自然而然可以得出规律： f(n) = f(n-1) + f(n-2)， (n > 2)。

 

public int RectCover(int target) {
        if(target <= 0){
            return 0;
        }
        else if(target == 1){
            return 1;
        }
        else if(target == 2){
            return 2;
        }else{
            return RectCover(target-1) + RectCover(target-2);
        }
}

上一篇：剑指Offer【Java版】T1-5