剑指 第2.4章 算法和数据操作

旋转数组最小的数字

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

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int n = rotateArray.size();
        int res;
        if (n == 0) return 0;
        for (int i = 0; i < n; i++){
            if (rotateArray[i] <= rotateArray[i+1]) continue;
            else {
                res = rotateArray[i+1];
                break;
            }
        }
        return res;
    }
};

其次，如果数组中没有重复元素的话，可以用二分法：旋转数组由两个有序数组组成，用left,right指针指向头部和尾部元素，考察中间位置元素的值（与left比较），可知中间元素属于前后那个有序数组，相应更新left,right,这样left始终在前面数组中，right始终在后面数组中，最后left指向前面数组的最后元素，right指向后面数组的第一个元素（即为整个数组的最小值）。如果有重复元素的话，中间位置的元素可能与left,right所指的元素相同（三者相同），这时就无法判断中间元素属于前面序列还是后面序列，只能顺序查找。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int n = rotateArray.size();
        if(n==0) return 0;
        int left = 0, right = n-1;
        int mid = 0;
        while(rotateArray[left] >= rotateArray[right]){
            if(right == left+1) break;
            mid = (left+right)/2;
            if(rotateArray[left]==rotateArray[mid]&&rotateArray[mid]==rotateArray[right]){
                int res = rotateArray[left];
                for(int i=left+1; i<right; i++){
                    if (rotateArray[i]<res) res = rotateArray[i];
                }
                return res;
            }
            if(rotateArray[mid] >= rotateArray[left]) left = mid;
            else right = mid;
        }
        return rotateArray[right];
    }
};

斐波那契数列

题目：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
思路：首先，递归求解时间复杂度太高，不可取。主要有三种方法：
最快的方法，用公式，时间复杂度O（1）。

class Solution {
public:
    int Fib(int n) {
        const double s = sqrt(5);
        return (pow((1+s)/2, n) - pow((1-s)/2, n))/s;
    }
}

第二快的方法，矩阵法，时间复杂度O（lgn）

//定义2×2矩阵；  
struct Matrix2by2  
{  
    //数据成员  
    int m00;  
    int m01;  
    int m10;  
    int m11;  
    //构造函数  
    Matrix2by2(int m_00,int m_01,int m_10,int  m_11)  
    {  
        m00 = m_00;  
        m01 = m_01;  
        m10 = m_10;  
        m11 = m_11;  
    }  

};  

//定义2×2矩阵的乘法运算  
Matrix2by2 MatrixMultiply(const Matrix2by2& matrix1,const Matrix2by2& matrix2)  
{  
    Matrix2by2 matrix12(1,1,1,0);  
    matrix12.m00 = matrix1.m00 * matrix2.m00 + matrix1.m01 * matrix2.m10;  
    matrix12.m01 = matrix1.m00 * matrix2.m01 + matrix1.m01 * matrix2.m11;  
    matrix12.m10 = matrix1.m10 * matrix2.m00 + matrix1.m11 * matrix2.m10;  
    matrix12.m11 = matrix1.m10 * matrix2.m01 + matrix1.m11 * matrix2.m11;  
    return matrix12;  

}  

//定义2×2矩阵的幂运算  
Matrix2by2 MatrixPower(unsigned int n)  
{  
    Matrix2by2 matrix(1,1,1,0);  
    if (n == 1)  
    {  
        matrix = Matrix2by2(1,1,1,0);  
    }  
    else if (n % 2 == 0)  
    {  
        matrix = MatrixPower(n / 2);  
        matrix = MatrixMultiply(matrix, matrix);  
    }  
    else if (n % 2 == 1)  
    {  
        matrix = MatrixPower((n-1) / 2);  
        matrix = MatrixMultiply(matrix, matrix);  
        matrix = MatrixMultiply(matrix, Matrix2by2(1,1,1,0));  
    }  
    return matrix;  
}  
//计算Fibnacci的第n项  
int fib(unsigned int n)  
{  
    if (n == 0)  
        return 0;  
    if (n == 1)  
        return 1;  

    Matrix2by2 fibMatrix = MatrixPower(n-1);  
    return fibMatrix.m00;  

}  

第三种方法，时间复杂度O（n），维护前后两个指针，后面的指针从1开始走n-1步就到了第n个位置，同时更新两个指针所指的值。

class Solution {
public:
    int Fibonacci(int n) {
        int f = 0, g = 1;
        if (n == 0) return f;
        if (n == 1 || n == 2) return g;
        for (int i=1;i<n;i++){
            g = f + g;
            f = g - f;
        }
        return g;
    }
};

跳台阶

题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
思路：与上一题思路相同。f(0)=0,f(1)=1,f(2)=2,从f(3)开始，f(n)=f(n-1)+f(n-2),维护前后两个指针f,g同时向前移动n-2步。

class Solution {
public:
    int jumpFloor(int number) {
        if(number<=2) return number;
        int f = 1, g = 2; //f(1)=1, f(2)=2
        for (int i = 2; i < number; i++){
            g = f + g;
            f = g - f;
        }
        return g;
    }
};

变态跳台阶

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

class Solution {
public:
    int jumpFloorII(int number) {
        //f(0)=0, f(1)=1, f(n)=f(n-1)+f(n-2)+...+f(1)+1 (n>=2)
        //f(n-1)=f(n-2)+..+f(1)+1
        //so, f(n)=2*f(n-1) (n>=2)
        return 1<<(number-1);
    }
};

矩阵覆盖

题目：我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
思路：本质上是斐波那契数列。

class Solution {
public:
    int rectCover(int number) {
        //f(0)=0, f(1)=1, f(2)=2, f(n)=f(n-1)+f(n-2) (n>=3)
        if (number < 3) return number;
        int f = 1, g = 2;
        for (int i = 2; i < number; i++){
            g = f + g;
            f = g - f;
        }
        return g;
    }
};

二进制中1的个数

题目：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路：
将n和1做与运算，1左移1位再做与运算，依次进行下去，32位整数需要循环32次。

class Solution {
public:
     int  NumberOf1(int n) {
         int cnt = 0;
         unsigned int flag = 1;
         while(flag){
             if(n&flag) ++cnt;
             flag = flag << 1;
         }
         return cnt;
     }
};

(n-1)&n 可以将n中最右边的1改为0，据此可以减少循环次数。

class Solution {
public:
     int  NumberOf1(int n) {
         int cnt = 0;
         while(n){
             ++cnt;
             n = (n-1)&n; //(n-1)&n 可以将n中最右边的1改为0
         }
         return cnt;
     }
};