【5-10】剑指offer

6. 题目描述

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

class Solution 
{
public:
    int minNumberInRotateArray(vector<int> rotateArray) 
    {
        /* 数组为空的时候，直接返回0 */
        if (rotateArray.size() == 0)
            return 0;
        
        /* 采用二分法查找 */
        int result = 0;
        int start = 0;
        int mid = start;
        int end = rotateArray.size() - 1;
        
        while (rotateArray[end] <= rotateArray[start])
        {
            if (end - start == 1)
            {
                mid = end;
                break;
            }
            
            mid = start + (end - start)/2;

            /* 如果三个数都一样的时候，采取顺序查找的方式 */
            if (rotateArray[mid] == rotateArray[start] && 
                rotateArray[mid] == rotateArray[end])
            {
                result = rotateArray[start];
                for (int i = start + 1; i <= end; i++)
                {
                    if (result > rotateArray[i])
                        result = rotateArray[i];
                }
                return result;
            }

            /* 注意判断条件 */
            if (rotateArray[mid] >= rotateArray[start])
                start = mid;
            else if(rotateArray[mid] <= rotateArray[end])
                end = mid;
        }
        
        return rotateArray[mid];
    }
};

 

 

 

 

7. 题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。

n<=39

/* 递归实现方式 */
class Solution {
public:
    int Fibonacci(int n) {
        /* f(n) = f(n - 1) + f(n - 2)  n >= 3
           f(n) = 1   (n = 1 or n = 2)
           f(n) = 0   (n = 0)
         */
        if (n == 0)
            return 0;
        
        if (n == 1 || n == 2)
            return 1;
        
        return Fibonacci(n - 1) + Fibonacci(n - 2);
    }
};

#include <iostream>
#include <vector>
using namespace std; 
class Solution 
{
public:    
    int Fibonacci(int n) 
    {        
        //若n==0，则返回0
        if(n == 0)            
            return 0;

        //若n==1或2，则返回1        
        if(n<=2)            
            return 1;

        //若n>=3，则迭代求斐波拉契数列        
        int *array = new int[n+1];        
        array[0] = 0;        
        array[1] = 1;
        array[2] = 1;                
        int i = 3;        
        while(i <= n)        
        {            
            array[i] = array[i-1] + array[i-2];            
            i++;        
        }                

        int temp = array[i-1];        
        delete [] array;        
        array = NULL;        
        return temp;    
    }
}; 

/* 简单测试 */
int main()
{
    Solution s;
    cout<<s.Fibonacci(10)<<endl;
    return 0;
}

 

 

8. 题目描述

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

 

// 递归实现
class Solution 
{
public:
    int jumpFloor(int number) 
    {
        if(number == 1)
            return 1;
        if (number == 2)
            return 2;
        
        return jumpFloor(number - 1) + jumpFloor(number - 2);
    }
};

//迭代实现
class Solution 
{
public:
    int jumpFloor(int number) 
    {
        if(number == 1)
            return 1;
        if (number == 2)
            return 2;
        
        //return jumpFloor(number - 1) + jumpFloor(number - 2);
        int *array = new int[number + 1];
        array[0] = 0;
        array[1] = 1;
        array[2] = 2;
        int i = 3;
        while (i <= number)
        {
            array[i] = array[i - 1] + array[i - 2];
            if (i == number)
                break;
            i++;
        }
        
        int tmp = array[i];
        delete []array;
        array = NULL;
        
        return tmp;
    }
};

 

 

 

 

9. 题目描述

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

 跳法为：F(n) = 2^(n-1)

 

class Solution 
{
public:    
    int jumpFloorII(int number) 
    {        
        if(number == 0)            
            return 0;     
   
        if(number == 1)            
            return 1;                

        int temp = 1;        
        while(number>1)    
        {            
            temp *= 2;            
            number--;        
        }        

        return temp;    
    }
};

 

 

10. 题目描述

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

分析：f(n) = f(n-1)+f(n-2); f(1) = 1; f(2) = 2;

class Solution 
{
public:    
    int rectCover(int number) 
    {                
        if(number == 0)            
            return 0;        

        if(number == 1)            
            return 1;        

        if(number == 2)            
            return 2;                

        int first = 1;        
        int second = 2;        
        int add = 0;        
        while(number >= 3)        
        {            
            add = first + second;            
            first = second;            
            second = add;            
            number--;        
        }    
            
        return add;    
    }
};