剑指 第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;
     }
};
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值