《剑指Offer》力扣刷题笔记（03-10）

《剑指Offer》力扣刷题笔记（03-10）

最近确实有点闲，想在进组搬砖之前找点有意义的事干，于是，就开始刷《剑指Offer》、《程序员面试金典》等书上的题目，也为三年之后的校招提前做好准备，是不是有点早。。。
传送门： 剑指 Offer（第 2 版）。全部都是用c++写的。

---

剑指 Offer 03. 数组中重复的数字

时间复杂度O(n)，空间复杂度S(1)，要比哈希表还好。

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        int len=nums.size();
        for(int i=0;i<len;i++)
        {
            while(nums[i]!=i)
            {
                if(nums[i]==nums[nums[i]])
                {
                    return nums[i];
                }
                else
                {
                    swap(nums[i],nums[nums[i]]);
                }
            }
        }
        return -1;
    }
};

剑指 Offer 04. 二维数组中的查找

逐步缩小范围，时间复杂度降到O(n)。

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if(matrix.size()==0||matrix[0].size()==0)
        {
            return false;
        }
        int n=matrix.size();
        int m=matrix[0].size();
        int x=0;
        int y=m-1;
        while(x<n&&y>=0)
        {
            if(matrix[x][y]==target)
            {
                return true;
            }
            else if(matrix[x][y]>target)
            {
                y--;
            }
            else if(matrix[x][y]<target)
            {
                x++;
            }
        }
        return false;
    }
};

剑指 Offer 05. 替换空格

class Solution {
public:
    string replaceSpace(string s) {
        int lens=s.size();
        string t="";
        string a="%20";
        for(int i=0;i<lens;i++)
        {
            if(s[i]!=' ')
            {
                t+=s[i];
            }
            else
            {
                t+=a;
            }
        }
        return t;
    }
};

剑指 Offer 06. 从尾到头打印链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> res;
        if(head==NULL)
        {
            return res;
        }
        ListNode *p=head;
        while(p!=NULL)
        {
            res.push_back(p->val);
            p=p->next;
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

剑指 Offer 07. 重建二叉树

传参麻烦一点，一种好方法是定义成员变量，我比较懒，就不改了吧。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0||inorder.size()==0)
        {
            return NULL;
        }
        TreeNode* root=new TreeNode(preorder[0]);
        create(root,preorder,inorder,0,0,inorder.size()-1);
        return root;
    }

    void create(TreeNode *t,vector<int>& preorder, vector<int>& inorder,int x1,int x2,int y2)
    {
        int pos=0;
        while(preorder[x1]!=inorder[pos])
        {
            pos++;
        }
        int len1=pos-x2;
        int len2=y2-pos;
        if(len1>0)
        {
            t->left=new TreeNode(preorder[x1+1]);
            create(t->left,preorder,inorder,x1+1,x2,pos-1);
        }
        if(len2>0)
        {
            t->right=new TreeNode(preorder[x1+len1+1]);
            create(t->right,preorder,inorder,x1+len1+1,pos+1,y2);
        }
    }

};

剑指 Offer 09. 用两个栈实现队列

有种豁然开朗的感觉，不禁感叹还有这种操作，骚是骚了点。。

class CQueue {
public:
    stack<int> s1;
    stack<int> s2;

    CQueue() {
        
    }
    
    void appendTail(int value) {
        s1.push(value);
    }
    
    int deleteHead() {
        int res=-1;
        if(!s2.empty())
        {
            res=s2.top();
            s2.pop();
        }
        else
        {
            while(!s1.empty())
            {
                int num=s1.top();
                s1.pop();
                s2.push(num);
            }
            if(!s2.empty())
            {
                res=s2.top();
                s2.pop();
            }
        }
        return res;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

剑指 Offer 10- I. 斐波那契数列

空间复杂度为S(1)的解法，来回倒腾，简单实用。书中还提供了一种矩阵快速幂的解法，之前也接触过，感觉有点曲高和寡了。

class Solution {
public:
    const int mod=1e9+7;
    int fib(int n) {
        int a,b,c;
        a=0;
        b=1;
        for(int i=2;i<=n;i++)
        {
            c=(a+b)%mod;
            a=b;
            b=c;
        }
        if(n==0)
        {
            return 0;
        }
        else if(n==1)
        {
            return 1;
        }
        else
        {
            return c;
        }
    }
};

剑指 Offer 10- II. 青蛙跳台阶问题

第一次接触dp的时候就是做的这道题，印象深刻。

class Solution {
public:
    const int mod=1e9+7;
    int numWays(int n) {
        int a,b,c;
        a=1;
        b=2;
        for(int i=3;i<=n;i++)
        {
            c=(a+b)%mod;
            a=b;
            b=c;
        }
        if(n==1||n==0)
        {
            return 1;
        }
        else if(n==2)
        {
            return 2;
        }
        else
        {
            return c;
        }
    }
};

---

总结

这一期就这样了，都是一些入门题，但是背后的一些知识点还是很有意思的，后面也是10个1组这样记录吧。