程序员面试金典-刷题笔记

最新推荐文章于 2023-06-16 16:27:02 发布
最新推荐文章于 2023-06-16 16:27:02 发布
阅读量253 收藏 1
点赞数 1
分类专栏： 刷题笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_38041680/article/details/116569410
版权

面试题 01.01. 判定字符是否唯一
 方法一：哈希表
 比较原数组和哈希表的长度，如果相等，说明没有重复元素；

class Solution {
public:
    bool isUnique(string astr) {
        int n=astr.size();
        unordered_set<char> ret;
        for(auto c:astr){
            ret.insert(c);
        }
        return ret.size()==n;
    }
};
  • 时间复杂度O(N)
  • 空间复杂度O(N)

 方法二：位运算 可以利用一个int类型的变量(mask)

class Solution {
public:
    bool isUnique(string astr) {
        int mask = 0;
        for (char& i : astr) {
            if (mask & (1 << (i - 'a'))) return false;
            mask |= (1 << (i - 'a'));
        }
        return true;
    }
};

 时间复杂度O(N) 空间复杂度O(1)

面试题 01.02. 判定是否互为字符重排

 方法一：先排序再判断是否相等

class Solution {
public:
    bool CheckPermutation(string s1, string s2) {
        sort(s1.begin(),s1.end());
        sort(s2.begin(),s2.end());
        return s1==s2;
    }
};

面试题 01.03. URL化

 方法一：在原数组上修改 先遍历数组计算非空格字符的数量num ，然后计算空格数length-num，然后扩充数组的长度，最后利用双指针遍历 遇到空格就插入“%20”；

class Solution {
public:
    string replaceSpaces(string S, int length) {
        int num=0;
        for(int i=0;i<length;i++){
            if(S[i]!=' ') num++;
        }
        int kong=length-num;
        S.resize(num+kong*3);
        int j=S.size()-1;
        for(int i=length-1;i>=0;i--){
            if(S[i]!=' ')S[j--]=S[i];
            else{
                S[j--]='0';
                S[j--]='2';
                S[j--]='%';
            }  
        }
       return S;
    }
};

 时间复杂度O(N) 空间复杂度O(1)

面试题 01.04. 回文排列

 方法一：哈希表

class Solution {
public:
    bool canPermutePalindrome(string s) {
        unordered_set<char> st;
        for(auto c: s){
            if(st.count(c)) st.erase(c);
            else st.insert(c);
        }
    return st.size()<=1;
    }
};

 时间复杂度O(N) 空间复杂度O(N)

面试题 01.05. 一次编辑

方法一：一次遍历

class Solution {
public:
    bool oneEditAway(string first, string second) {
        int n1=first.size();
        int n2=second.size();
        if(abs(n1-n2)>1) return false;
        if(first==second) return true;
        int count=0;
        int i=0,j=0;
        while(i <n1 && j <n2){
            if(first[i++] == second[j++]){
                continue;
            }
            count++;
            if(count > 1) return false;
            if( n1> n2){
                j--;
            }else if(n1<n2){
                i--;
            }
        }
        return true;
    }
};

 时间复杂度O(N) 空间复杂度O(1)

面试题 01.06. 字符串压缩

方法一：一次遍历

class Solution {
public:
    string compressString(string S) {
      if(S.size()==0) return S;
      string ans="";
      int cnt=1;
      char ch=S[0];
      for(int i=1; i < S.size();i++){
          if(ch ==S[i]) cnt++;
          else {
              ans+=ch+to_string(cnt);
              ch=S[i];
              cnt=1;
          }
      }
    ans+=ch+to_string(cnt);
    return ans.size()>=S.size() ? S:ans;
    }
};

时间复杂度O(N) 空间复杂度O(1)

面试题 01.07. 旋转矩阵

方法一：翻转代替旋转 首先进行对角线翻转 然后进行竖轴翻转

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n=matrix.size();
        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){
                swap(matrix[i][j],matrix[j][i]);
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n/2;j++)
            swap(matrix[i][j],matrix[i][n-1-j]);
        }
    }
};

时间复杂度O(N^2) 空间复杂度O(1)

方法二：原地旋转

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n=matrix.size();
        for(int i=0;i<n/2;i++){
            for(int j=0;j<(n+1)/2;j++){
                int temp = matrix[i][j];
                matrix[i][j]=matrix[n-j-1][i];
                matrix[n-j-1][i]=matrix[n-i-1][n-j-1];
                matrix[n-i-1][n-j-1] = matrix[j][n-i-1];
                matrix[j][n-i-1]=temp;
            }
        }
    }
};

时间复杂度O(N^2) 空间复杂度O(1)

面试题 01.08. 零矩阵

方法一：先用数组将零元素的坐标存下来 然后修改为0；

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        if(matrix.size() ==0 || matrix[0].size()==0) return ;
        vector<pair<int,int>> ret;
        for(int i=0;i<matrix.size();i++){
        for(int j=0;j<matrix[0].size();j++){
            if(matrix[i][j]==0) ret.push_back({i,j});
        }
        }
        for(int i=0;i<ret.size();i++){
            int n1=ret[i].first;
            int n2=ret[i].second;
            for(int j=0;j<matrix[0].size();j++){
                matrix[n1][j]=0;
            }
            for(int k=0;k<matrix.size();k++){
                matrix[k][n2]=0;
            }

        }
    }
};

 时间复杂度O(NM)

面试题 01.09. 字符串轮转

方法一：将s1和s1拼接 然后在拼接后的s1中找s2

class Solution {
public:
    bool isFlipedString(string s1, string s2) {
        if(s1.size() != s2.size()) return false;
        s1+=s1;
        int n1=0,n2=0;
        while( n1 < s1.size() && n2 < s2.size()){
            if(s1[n1]==s2[n2]){
                n1++;
                n2++;
            }
            else {
                n2=0;
                n1=n1-n2+1;
            }
        }
    return n2==s2.size();
    }
};

 时间复杂度O(N) 空间复杂度O(1)

方法二：使用标记数组

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int m=matrix.size();
        int n=matrix[0].size();
        vector<int> row(m),col(n);
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(matrix[i][j]==0)
                row[i]=col[j]=true;
            }
        }
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(row[i] || col[j])
                matrix[i][j]=0;
            }
        }
    }
};

时间复杂度O(MN) 空间复杂度O（M+N）

面试题 02.01. 移除重复节点

方法一：哈希表

class Solution {
public:
    ListNode* removeDuplicateNodes(ListNode* head) {
        if(!head) return nullptr;
        unordered_set<int> st;
        ListNode* curr=head;
        st.insert(curr->val);
        while(curr->next){
            if(st.count(curr->next->val)){
                curr->next=curr->next->next;
            }else{
                st.insert(curr->next->val);
                curr=curr->next;
            }
        }
    return head;
    }
};

时间复杂度O(N) 空间复杂度O(N)

方法二：双循环

class Solution {
public:
    ListNode* removeDuplicateNodes(ListNode* head) {
        if(!head) return nullptr;
        ListNode* curr=head;
        while(curr){
            ListNode* pre=curr;
            while(pre->next){
                if(pre->next->val==curr->val){
                    pre->next=pre->next->next;
                }else{
                    pre=pre->next;
                }
            }
            curr=curr->next;
        }
    return head;
    }
};

时间复杂度O(N^2) 空间复杂度O(1)

面试题 02.02. 返回倒数第 k 个节点

方法一：双指针 前指针先走k步，后指针开始走；当前指针走到末尾，则后指针就是倒数第k个指针

class Solution {
public:
    int kthToLast(ListNode* head, int k) {
        if(!head) return -1;
        ListNode* pre=head,*curr=head;
        while(k--){
            pre=pre->next;
        }
        while(pre){
            pre=pre->next;
            curr=curr->next;
        }
      return curr->val;
    }
};

时间复杂度O(N) 空间复杂度O(1)

面试题 02.03. 删除中间节点

方法一：将下一个节点赋值给当前节点 然后删除下一个节点

class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val=node->next->val;
        node->next=node->next->next;
    }
};

面试题 02.04. 分割链表

方法一：分割链表

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode* smallhead=new ListNode(0);
        ListNode* small=smallhead;
        ListNode* largehead=new ListNode(0);
        ListNode* large=largehead;
        while(head){
            if(head->val<x){
                small->next=head;
                small=small->next;
            }else{
                large->next=head;
                large=large->next;
            }
            head=head->next;
        }
        large->next=nullptr;
        small->next=largehead->next;
        return smallhead->next;
    }
};

时间复杂度O(N) 空间复杂度O(1)

面试题 02.05. 链表求和

方法一：递归

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        return addcore(l1,l2,0);
    }
    ListNode* addcore(ListNode* l1,ListNode* l2,int carry){
        if(!l1 && !l2 && carry==0) return nullptr;
        int val = carry + (l1? l1->val : 0) + (l2? l2->val : 0);
        carry = val / 10;
        ListNode* res = new ListNode (val%10);
        res -> next=addcore(l1 ? l1->next: nullptr,l2? l2->next:nullptr,carry);
        return res;
    }
};

方法二：迭代 先对应节点求和再加上进位

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    if(!l1 && !l2) return nullptr;
    ListNode* head=new ListNode(-1),*p=head;
    int carry=0;
    while(l1 || l2 || carry){
        int sum=0;
        if(l1){
            sum+=l1->val;
            l1=l1->next;
        }
        if(l2){
            sum+=l2->val;
            l2=l2->next;
        }
        sum+=carry;
        ListNode* node=new ListNode(sum%10);
        carry=sum/10;
        p->next=node;
        p=p->next;
    }
    return head->next;
   }
};

时间复杂度O(N)

面试题 02.06. 回文链表

方法一：先将值复制到数组中后用双指针法

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int> vals;
        while (head != nullptr) {
            vals.emplace_back(head->val);
            head = head->next;
        }
        for (int i = 0, j = (int)vals.size() - 1; i < j; ++i, --j) {
            if (vals[i] != vals[j]) {
                return false;
            }
        }
        return true;
    }
};

时间复杂度O(N) 空间复杂度O(N)

方法二：快慢指针 用快慢指针找到中点 然后将后半段反转

面试题 02.08. 环路检测

方法一：哈希表

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode *> visited;
        while (head != nullptr) {
            if (visited.count(head)) {
                return head;
            }
            visited.insert(head);
            head = head->next;
        }
        return nullptr;
    }
};

时间复杂度O(N) 空间复杂度O(N)

方法二：快慢指针

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(!head) return nullptr;
        ListNode *fast=head,*slow=head;
        while(fast){
          slow=slow->next;
          if(fast->next==nullptr){
              return nullptr;
          }
          fast=fast->next->next;
          if(slow==fast){
              ListNode* node=head;
              while(node!=slow){
                  node=node->next;
                  slow=slow->next;
              }
              return node;
          }
        } 
        return nullptr;
    }
};

时间复杂度O(N) 空间复杂度O(1)

面试题 04.01. 节点间通路

方法一：深度优先遍历 利用一个visited的数组来记录是否遍历了边 每次遍历：1.看是否能直接转到 2.如果不到就考虑这一条是target的情况，然后更新新的target 3然后回溯

class Solution {
public:
    bool findWhetherExistsPath(int n, vector<vector<int>>& graph, int start, int target) {
        int k=graph.size();
        vector<bool> visite(k,false);
        for(int i=0;i<k;i++){
            if(graph[i][0]==start && graph[i][1]==target){
                return true;
            }
        }
        return dfs(visite,graph,start,target);
    }
    bool dfs(vector<bool>& visite,vector<vector<int>>& graph,int start,int target){
        for(int i=0;i<graph.size();i++){
            if(!visite[i]){
                if(graph[i][0]==start && graph[i][1]==target) return true;
                visite[i]=true;
                if(graph[i][1]==target && dfs(visite,graph,start,graph[i][0])) return true;
                visite[i]=false;
            }
        }
    return false;
    }
};

面试题 04.02. 最小高度树

方法一：迭代算法 先序遍历

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.size()==0) return nullptr;
        return sortA(nums,0,nums.size()-1);
    }
    TreeNode* sortA(vector<int>& nums,int low,int high){
        if(low>high) return nullptr;
        int mid=(low+high)>>1;
        TreeNode* tmp=new TreeNode(nums[mid]);
        tmp->left=sortA(nums,low,mid-1);
        tmp->right=sortA(nums,mid+1,high);
        return tmp; 
    }
};

时间复杂度O(N) 空间复杂度O(logN)

面试题 04.03. 特定深度节点链表

方法：广度优先搜索

class Solution {
public:
    vector<ListNode*> listOfDepth(TreeNode* tree) {
        vector<ListNode*> res;
        if(!tree) return {};
        queue<TreeNode*> q;
        q.push(tree);
        while(!q.empty()){
            int n=q.size();
            ListNode* tmp=new ListNode(0);
            ListNode* ret=tmp;
            for(int i=0;i<n;i++){
                TreeNode* node=q.front();
                q.pop();
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
                ListNode* temp=new ListNode(node->val);
                ret->next=temp;
                ret=ret->next;        
            }
            res.push_back(tmp->next);
        }
        return res;
    }
};

时间复杂度O(N) 空间复杂度O(N)

面试题 04.05. 合法二叉搜索树

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(!root) return true;
        return dechose(root,LONG_MIN,LONG_MAX);
    }
    bool dechose(TreeNode* node,long long low,long long high){
        if(!node) return true;
        if(node->val <=low || node->val >=high){
            return false;
        }
        return dechose(node->left,low,node->val) && dechose(node->right,node->val,high);
    }
};

时间复杂度O(N) 空间复杂度O(N)

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> st;
        if(!root) return true;
        long long inorder=LONG_MIN;

        while(!st.empty() || root!=nullptr){
            while(root != nullptr){
                st.push(root);
                root=root->left;
            }
            root=st.top();
            st.pop();
            if(root->val <=inorder) return false;
            inorder=root->val;
            root=root->right;
        }
       return true;
    }
};

时间复杂度O(N) 空间复杂度O(N)

面试题 04.06. 后继者

思路：迭代法

class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        if (root == nullptr || p == nullptr)
            return nullptr;
        if (p->val >= root->val)
            return inorderSuccessor(root->right, p);
        else {
            TreeNode* left = inorderSuccessor(root->left, p);
            return left ? left : root;
        }        
    }
};

时间复杂度O(N) 空间复杂度O(1)

思路：首先查找root->val

class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        if(!root) return nullptr;
        TreeNode* pre=nullptr;
        while(root->val !=p->val){
            if(root->val <p->val)
              root=root->right;
            else {
                pre=root;
                root=root->left;
            }
        }

        if(root->right ==nullptr) return pre;
        else{
            root=root->right;
            while(root->left != nullptr){
                root=root->left;
            }
        return root;
        }      
    }
};

时间复杂度O(N)

面试题 04.08. 首个共同祖先

思路： 如果root为空，或rootp或rootq，返回root；分别将root->left、root->right作为根节点、调用自身，得到返回值left、right；若left为空，若right不为空，返回root，否则返回left；否则返回right。

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==nullptr || root==p || root==q) return root;
        TreeNode* left=lowestCommonAncestor(root->left,p,q);
        TreeNode* right=lowestCommonAncestor(root->right,p,q);
        if(left != nullptr){
            return right ? root : left;
        }
        else return right;
    }
};

时间复杂度O(N) 空间复杂度O(N)

思路：存储父节点

面试题 04.10. 检查子树

思路：迭代算法

class Solution {
public:
    bool checkSubTree(TreeNode* t1, TreeNode* t2) {
        if(t1==nullptr || t2==nullptr) return false;
        return recure(t1,t2) || checkSubTree(t1->left,t2) || checkSubTree(t1->right,t2);
    }

    bool recure(TreeNode* A ,TreeNode* B){
        if(B==nullptr) return true;
        if(A==nullptr || A->val!=B->val) return false;
        return recure(A->left,B->left) && recure(A->right,B->right); 
    }
};

时间复杂度O(MN) 空间复杂度O(M)

面试题 04.12. 求和路径

class Solution {
    private: 
    int Depth(TreeNode* root){
        if(!root) return 0;
        return max(Depth(root->left),Depth(root->right))+1;
    }

public:
    int ret=0;
    int pathSum(TreeNode* root, int sum) {
        if(root==nullptr) return ret;
        int depth = Depth(root);
        int path[depth];
        memset(path,0,sizeof(int)*depth);
        dfs(root,sum,path,0);
        return ret;
    }

 void dfs(TreeNode* curr,int sum,int* path,int level){
     if(curr == nullptr) return;
     path[level] = curr->val;
     int currSum=0;
     for(int i=level;i>=0;i--){
         currSum +=path[i];
         if(currSum == sum) ++ret;
     }
        dfs(curr->left, sum, path, level+1);
        dfs(curr->right, sum, path, level+1);
  }
};

面试题 08.01. 三步问题

思路：动态规划

class Solution {
public:
    int waysToStep(int n) {
        if(n==1) return 1;
        if(n==2) return 2;
        if(n==3) return 4;
        int  ret=0,first=1,second=2,third=4;

        for(int i=3;i<n;i++){
            ret=((first+second)%1000000007+third)%1000000007;
            first=second;
            second=third;
            third=ret;
        }
    return ret;
    }
};

面试题 08.02. 迷路的机器人

面试题 08.03. 魔术索引

普通遍历

class Solution {
public:
    int findMagicIndex(vector<int>& nums) {

        for(int i=0;i<nums.size();i++){
            if(nums[i]==i) return i;
        }
        return -1;
    }
};

时间复杂度O（N）空间复杂度O（1）

思路：二分法

Troy_horse
关注
专栏目录
程序员面试除了刷题，就真没别的可做了么？
java_121388的博客
04-17 557
之前说过好几篇关于面试的，也和很多朋友聊过面试相关的经验，毕竟在年龄和技术一点点积累到现在之前，大家都是一步步打怪升级上来的，现在终于也是到了别人向我请教的点了，不敢说指点迷津，但是可以把自己的感悟拿出来和大家聊聊。
程序员面试金典-第五版
07-22
资源名称：程序员面试金典-第五版资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
谈谈程序员面试之刷题
weixin_34252686的博客
07-30 1532
2019独角兽企业重金招聘Python工程师标准>>> ...
程序员面试刷题网
xuezhunzhen9743的博客
09-10 4570
刷题网站 牛客网 http://www.nowcoder.com/ 一个办法就是刷题，国内外都有一些网站来帮助程序员刷题，大部分是算法题。 脑客 http://www.knockgate.com/ 另一个专注于程序员刷题的网站，没有什么真题，但是有很多培训和视频 九章算法 http://www.jiuzhang.com/ 提供大量的算法培训和讲座内容，同时能够查询所有leet...
程序员面试金典笔记
谜底的博客
03-10 340
面试题01.01 判断字符串中字符是否唯一 遇到题目，先想需要考虑的情况： 字符串是ASCII字符串还是Unicode字符串？假设为ASCII。 首先得有字符串长度判定，超出长度后直接false。 思路主要是使用位向量的方法。我们可以使用一个int类型的变量（下文用checker表示）来代替长度为26的bool数组。。假设这个变量占26个bit（在多数语言中，这个值一般不止26），那么我们可...
程序员面试 刷题推荐
那些年....的专栏
11-04 6020
转自http://www.kuqin.com/shuoit/20150608/346480.html 刷题注意的事： 1、要经常在白板或者纸上写代码，检查是否漏掉情况，然后键入电脑运行测试写的代码； 2、用自己最擅长的语言去练习和面试，一般选择的语言是Java，Python，C，C++； 3、在睡觉前回忆一下今天刷的题或者阅读一些面试有关的书籍，研究表明睡前回忆或者阅读有非
程序员面试金典-5版
08-02
本书是原谷歌资深面试官的经验之作，层层紧扣程序员面试的每一个环节，全面而详尽地介绍了程序员应当如何应对面试，才能在面试中脱颖而出。第1～7 章主要涉及面试流程解析、面试官的幕后决策及可能提出的问题、面试...
程序员面试金典-中文第五版 pdf
11-21
程序员面试金典-中文第五版 pdf 程序员面试金典-中文第五版 pdf
程序员面试金典-中文第五版-高清带目录.txt
05-09
本书是原谷歌资深面试官的经验之作，层层紧扣程序员面试的每一个环节，全面而详尽地介绍了程序员应当如何应对面试，才能在面试中脱颖而出。第1～7 章主要涉及面试流程解析、面试官的幕后决策及可能提出的问题、面试...
阿龙的学习笔记---《程序员面试金典》笔记 --- 各类型题目要点
阿龙的博客
06-14 158
1. 数组与字符串 提到了散列表（哈希表）和动态数组，做题时可能要想到用散列表。 字符串使用哈希表可以采用一个256字节的数组来实现，因为ASCII只有0~256。 双指针要会用，好用。 数组和字符串，由于在中间删除插入等会导致后面的都变动，所以最好能从尾部开始调整。 1. 链表 链表在做题时搞清楚是单向链表、还是双向链表、还是循环链表等。 链表的访问用时不定，不是O(1)所以比较麻烦，而且有时会用到递归。 删除、插入等操作时，一定要记得判断是否为链表头或者尾！这部分的操作会不同。 快慢..
程序员面试之刷题推荐
gaoyi221119的博客
03-10 782
刷题注意的事：1、要经常在白板或者纸上写代码，检查是否漏掉情况，然后键入电脑运行测试写的代码；2、用自己最擅长的语言去练习和面试，一般选择的语言是Java，Python，C，C++；3、在睡觉前回忆一下今天刷的题或者阅读一些面试有关的书籍，研究表明睡前回忆或者阅读有非常好的记忆效果（可以参考论文研究）；4、在面试最期望去的公司前去面试一些其他公司，最好的准备是去真实环境中体验面试；推荐刷题面试书籍：
（程序员代码面试指南）刷题
youyou_cumt的博客
03-19 243
（程序员代码面试指南）刷题 题目名称《机器人到达指定位置方法数》 记录一下牛客网刷题过程中遇到的问题。 问题 ：java取模 在题目中需要对答案进行（10^9+7）取模，使用代码（1） 则编译通过，结果错误。使用代码（2）则可以通过。 int MOD = 10^9+7; //(1) int MOD = (int)(1E9+7); //(2) 原因分析 java 中求a的n次方，不可以使用“^”,应该使用函数 po
刷题-程序员面试宝典
DavidHan008
08-23 1990
最近快面临找工作了，开始每天的刷题之旅 知识点1：关于与或非赋值操作 int x=2,y,z x*=(y=z=5);//x=2*5=10 x=(y&amp;z);//x=5 y的二进制是101 z的二进制是101 x=(y&amp;&amp;z);//x=1;两个&amp;&amp;表示布尔 同理可知（y|z）与（y||z）的区别 知识点2：统计1的个数 //这个函数返回的时候，形参...
刷题-《程序员面试金典》
ShenHang_的博客
06-27 514
class Solution { public: bool isUnique(string astr) { if(astr.size()==0)return true; unordered_set<char>myset={astr[0]}; for(int i=1;i<astr.size();i++) { if(myset.find(astr[i])!=myset.end()) .
程序员面试、刷题教程合集
duoshehuan6005的博客
06-22 445
包含Python、Java、C++等常见编程语言算法和数据结构的面试问题及刷题技巧课程介绍：https://www.aihorizon.cn/117百度网盘地址：https://pan.baidu.com/s/1I07CkzLCLgrEcEN9RfMgJQ?pwd=e5c4课程介绍：https://www.aihorizon.cn/119百度网盘地址：https://pan.baidu.com/s/1H_l8GuQ-rBhDdRJC33XJyA?pwd=q4r2课程介绍：https://www.aihori
刷题--程序员面试金典篇
Allen_Xu17
06-23 360
程序员面试金典的算法题解
《程序员代码面试指南》刷题集合
weixin_43022263的博客
05-13 586
1、在行列都排好序的矩阵中找指定的数 原题链接 思路：从右上角或者左下角开始比较，或者用二分查找 #include <bits/stdc++.h> using namespace std; int main() { int n, m, k; cin >> n >> m >> k; vector<int> ans(m); vector<vector<int>> tmp(n,ans); for (int i =
程序员面试刷编程题题型及对应思路
最新发布
Cluluxiu的博客
06-16 325
本文将列举程序员面试中常见的编程题题型和对应的解题思路，以供大家备考和练习，提高面试技能。
程序员面试金典：高清版
"程序员面试金典" 《程序员面试金典》是程序员面试准备的重要参考资料，尤其以其第五版备受关注。这是一本高清版本的书籍，具备完整的目录结构，非常适合读者做笔记和注释，以加深对内容的理解和记忆。书籍内容涵盖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值