牛客剑指offer刷题记录（二）

最新推荐文章于 2023-12-04 14:57:11 发布

NearXDU

最新推荐文章于 2023-12-04 14:57:11 发布

阅读量459

点赞数 1

分类专栏：笔试面试文章标签：剑指offer 笔试面试

本文链接：https://blog.csdn.net/zhangxiao93/article/details/74160429

版权

笔试面试专栏收录该内容

17 篇文章 1 订阅

订阅专栏

旋转数组的最小数字

旋转数组是指有序数组进行右移之后的得到数组。

要求数组中的最小数字， $O(n)$ 复杂度就可以搞定，如果要高效一点，需要用到二分查找的思路。

事实上，除了处理简单45123这样的序列，还得考虑有重复数字出现的旋转数组，例如11000

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int l=0;
        int r=rotateArray.size()-1;
        int m=0;
        while(l<r)
        {
            m=l+(r-l)/2;
            if(rotateArray[m]<rotateArray[r])
            {
                r=m;
            }
            else if(rotateArray[m]>rotateArray[r])
            {
                l=m+1;
            }
            else//相等只有减小Upper Bound
            {
                --r;
            }
        }
        return rotateArray[l];

    }
};

斐波拉切数列

$f(n)=f(n-1)+f(n-2)$
这是斐波拉切数列的方程，可以直接递归去做，也可以迭代计算，我这里用迭代的方式做：

class Solution {
    public:
    int Fibonacci(int n) 
    {
        if(0==n)
            return 0;
        if(1==n)
            return 1;

        int a1=1;
        int a0=0;
        int res;
        for(int i=2;i<=n;++i)
        {
            res=a0+a1;
            a0=a1;
            a1=res;
        }
        return res;

    }
};

跳台阶

理解一下题意的话，就是斐波拉切数列的变种。

class Solution {
public:
    int jumpFloor(int number) {
        if(1==number)
            return 1;
        if(2==number)
            return 2;
        int n1=1;
        int n2=2;
        for(int i=0;i<number-2;++i){
            int tmp=n2;
            n2+=n1;
            n1=tmp;
        }
        return n2;
    }
};

变态跳台阶

$f(n)=f(n-1)+...f(1)+f(0)$
$f(n-1)=f(n-2)+...f(1)+f(0)$
推出：
$f(n)=2*f(n-1)$
推出：
$f(n)=2^{(n-1)}$

class Solution {

public:
    int jumpFloorII(int number) {
        if(number<=0)
            return 0;
        return pow(2,number-1);
    }
};

矩形覆盖

同样是斐波拉契数列

class Solution {
public:
    int rectCover(int number) {
        //number==1 1
        //number==2 2
        if(number<=0)
            return 0;
        if(number==1)
            return 1;
        if(number==2)
            return 2;
        int n1=1;
        int n2=2;
        for(int i=0;i<number-2;++i){
            int tmp=n2;
            n2+=n1;
            n1=tmp;
        }
        return n2;

    }
};

二进制有多少个1

通过n&n-1这个操作可以把原来n所表示的二进制中最右边的1变成0，那么有多少次这样的操作，就表示有多少个1.

class Solution {
public:
     int  NumberOf1(int n) {
         int count=0;
         while(n)
         {
             ++count;
             n=n&(n-1);
         }
         return count;

     }
};

数值的整数次方

这题就是自己实现一个pow函数，并不难，在于优化。

比如2的4次方，可以两组两组相乘，2的5次方可以两组两组相乘之后再乘以基数。这就是考虑奇数与偶数次幂的情况了。

class Solution {
    double help(double base, int exponent)
    {
        if (exponent == 0)
            return 1;
        if (exponent == 1)
            return base;
        double tmp = help(base, exponent / 2);
        tmp*=tmp;
        if ((exponent & 1) == 1)
            tmp *= base;
        return tmp;
    }
public:
    double Power(double base, int exponent) {
        int flag = false;
        if (exponent < 0)
        {
            exponent = -exponent;
            flag = true;
        }
        double res = help(base, exponent);
        if (flag)
            res = 1 / res;
        return res;

    }
};

奇数位于偶数之前

剑指offer上的解法不能保证原有次序，思路是：
1.从前往后找到第一个偶数
2.从后往前找到第一个奇数

交换之。

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        int odd = 0;
        int even = array.size() - 1;
        while (odd < even)
        {
            while (odd < even && (array[odd] & 1) == 1)
                ++odd;
            while (odd < even && (array[even] & 1) == 0)
                --even;
            if (odd < even)
            {
                swap(array[odd], array[even]);
            }
        }
    }
};

而牛客上面要求新的序列不改变原来的次序，这样的话，可以重新开辟一个新的数组来保存。

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        vector<int>tmp;
        tmp.reserve(array.size());
        for(int i=0;i<array.size();++i){
            if((array[i]&0x1)==1)
                tmp.push_back(array[i]);
        }
        for(int i=0;i<array.size();++i){
            if((array[i]&0x1)==0)
                tmp.push_back(array[i]);
        }
        array.swap(tmp);
    }
};

链表中的倒数第K个节点

一个简单的办法就是，倒数第K个节点实际上就是顺数第n-K+1个节点，于是需要遍历两次。

有一个思路是，需要两个指针，第一个指针先走k-1步到第k个节点，第二个指针不动，然后两个指针再一起往后直到链表结尾，那么第二个指针便是倒数第k个节点了。

因为第k个节点是倒数n-k+1个节点，走到头，需要走n-k步，第一个个指针同时走n-k步就到了n-k+1个节点了。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        ListNode*p=pListHead;
        int i=k;
        while(i--){
            if(NULL==p)
                return NULL;
            p=p->next;
        }
        ListNode*r=pListHead;
        while(p!=NULL){
            p=p->next;
            r=r->next;
        }
        return r;
    }
};