给秋招加点料——Hot15道高频算法面试题！

最新推荐文章于 2022-04-02 23:57:11 发布
最新推荐文章于 2022-04-02 23:57:11 发布
阅读量964 收藏 5
点赞数 6
分类专栏： 面试题集 文章标签： 面试题集 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asbbv/article/details/118222819
版权

目录

1.链表篇

反转链表

难度：easy

考察次数：189

传送门

题目描述
输入一个链表，反转链表后，输出新链表的表头。

思路:创建三个指针，一个表示前一个结点pre，一个表示当前节点cur，一个表示后一个节点next。循环next=cur->next，cur->next=pre，pre=cur，cur=next，直到当前节点为NULL。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
    ListNode* cur=pHead,*pre=NULL,*next;
        while(cur!=NULL)
        {
            next=cur->next;
            cur->next=pre;
            pre=cur;
            cur=next;
        }
        return pre;}
};

判断链表中是否有环

难度：easy

考察次数：120

传送门

题目描述
判断给定的链表中是否有环。如果有环则返回true，否则返回false。
你能给出空间复杂度的解法么？

思路：采用快慢指针解决，慢指针每次向前移动一步，快指针每次向前移动2步，如果链表中有环，快慢指针一定会相遇，注意一下溢出，判断快指针的下一步是不是NULL，如果为NULL则fast->next->next就溢出了。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *fast=head,*cur=head;
        while(fast!=NULL&&fast->next!=NULL)
        {
            cur=cur->next;
            fast=fast->next->next;
            if(cur==fast)return true;
        }
        return false;
    }
};

合并有序链表

难度： middle

考察次数：57

传送门

题目描述

将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的，且合并后新链表依然有序。

思路：先确定表头，创建一个cur表示当前指针，之后比较两个链表表头节点，每次都让cur->next=较小表头的指针，并让该指针移动到其next，直到某链表为空，将剩余链表全部接到cur后面即可。

AC code

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param l1 ListNode类 
     * @param l2 ListNode类 
     * @return ListNode类
     */
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        // write code here
        ListNode* cur,*head;
            if(l1==NULL)return l2;
            else if(l2==NULL)return l1;
            else if(l1->val<=l2->val){cur=l1;l1=l1->next;}
        else {cur=l2;l2=l2->next;}
        head=cur;
        while(!(l1==NULL&&l2==NULL))
        {
            if(l2==NULL){cur->next=l1;l1=l1->next;}
            else if(l1==NULL) {cur->next=l2;l2=l2->next;}
            else if(l1->val<=l2->val){cur->next=l1;l1=l1->next;}
            else {cur->next=l2;l2=l2->next;}
            cur=cur->next;
        }
        return head;
    }
};

2.动态规划篇

跳台阶

难度: easy

考察次数： 55

传送门

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

思路： d[i]表示从0到第i个台阶总共的方案数。转移方程：dp[i]=dp[i-1]+dp[i-2]，因为当前台阶可以由前两级台阶走到，初始dp[0]=1,dp[1]=1
。

AC code

class Solution {
public:
    int jumpFloor(int number) {
    int dp[10000];
        dp[1]=1,dp[0]=1;
        for(int i=2;i<=number;i++)
        {
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[number];
    }
};

子数组的最大累加和

难度：easy

考察次数：52

传送门

题目描述

给定一个数组arr，返回子数组的最大累加和
例如，arr = [1, -2, 3, 5, -2, 6, -1]，所有子数组中，[3, 5, -2, 6]可以累加出最大的和12，所以返回12.
题目保证没有全为负数的数据
[要求]
时间复杂度为O(n)O(n)O(n)，空间复杂度为O(1)O(1)O(1)

思路：dp[i]为以第i个元素为结尾的最大累加和，状态转移方程：dp[i]=max(dp[i-1]+arr[i]，arr[i])，从这可看出其实dp[i]只与dp[i-1]有关，所以对于dp的存储只需要一个空间，每次更新当前dp即可dp(相当于更新后的dp[i])=max(dp(相当于dp[i-1])+arr[i]，arr[i])。

AC code

class Solution {
public:
    /**
     * max sum of the subarray
     * @param arr int整型vector the array
     * @return int整型
     */
    int dp=0,ans=0;
    int maxsumofSubarray(vector<int>& arr) {
        // write code here
        for(int i=0;i<arr.size();i++)
        {
            dp=max(dp,0)+arr[i];
            ans=max(ans,dp);
        }
        return ans;
        
    }
};

求路径

难度：easy

考察次数：15

传送门

题目描述

一个机器人在m×n大小的地图的左上角（起点）。
机器人每次向下或向右移动。机器人要到达地图的右下角（终点）。
可以有多少种不同的路径从起点走到终点？

在这里插入图片描述

备注：m和n小于等于100,并保证计算结果在int范围内

思路： dp[i][j]表示走到 位置 i,j 的路径数，状态转移方程 dp[i][j]=dp[i-1][j]+dp[i][j-1] ，注意边界的处理情况。

AC code

class Solution {
public:
    /**
     * 
     * @param m int整型 
     * @param n int整型 
     * @return int整型
     */
    
    long long dp[105][105];
    long long dfs(int x,int y,int n,int m)
    {
        if(dp[x][y])return dp[x][y];
        if(x<1||x>n||y<1||y>m)return 0;
        return dp[x][y]=dfs(x-1,y,n,m)+dfs(x,y-1,n,m);
    }
    long long uniquePaths(int m, int n) {
        // write code here
        dp[1][1]=1;
        return dfs(m,n,m,n);
    }
};

最长公共子串

难度：middle

考察次数：52

传送门

题目描述
给定两个字符串str1和str2,输出两个字符串的最长公共子串
题目保证str1和str2的最长公共子串存在且唯一。

思路： dp[i][j]代表str1串第以第i个字符结尾和str2串的公共串长度。状态转移方程：如果：str1[i]==str2[j]，dp[i][j]=dp[i-1][j-1]+1,如果str1[i]!=str2[j]，dp[i][j]=0。然后题目求的是最长串，那我们只需记录哪时dp[i][j]最大，最长公共串即为此时的i向前取dp[i][j]长度。

AC code

class Solution {
public:
    /**
     * longest common substring
     * @param str1 string字符串 the string
     * @param str2 string字符串 the string
     * @return string字符串
     */
    int dp[5005][5005];
        int ans=0;

   
        string LCS(string str1, string str2) {
        
        string str;
        for (int i = 0;i < str1.size();i++)
        {
            for (int j = 0;j < str2.size();j++)
            {
                if (str1[i] == str2[j])
                {
                    if (i - 1 >= 0 && j - 1 >= 0)
                    {
                        dp[i][j] = dp[i - 1][j - 1] + 1;
                        if (dp[i - 1][j - 1] + 1 > ans)
                        {
                            str = str1.substr(i - dp[i - 1][j - 1], dp[i - 1][j - 1] + 1);
                            ans = max(dp[i - 1][j - 1] + 1, ans);
                        }
                    }
                    else {[`
                        dp[i][j] = 1;
                        if (1 >= ans) { ans = 1;str = str1[i]; }
                    }
                }
                else dp[i][j] = 0;
            }
        }
        return str;
    }
    
};

3.树篇

两个节点最近公共祖先

难度：middle

考察次数：32

传送门

题目描述
给定一棵二叉树以及这棵树上的两个节点 o1 和 o2，请找到 o1 和 o2 的最近公共祖先节点。

思路： 用一个map[i]记录以当前节点i为根，如果子树有一个所要求的节点则map[i]=1,两个则map[i]=2，从根节点深度优先搜索，第一个map为二的节点即为最近的公共祖先。

AC code

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @param o1 int整型 
     * @param o2 int整型 
     * @return int整型
     */
   map<int, int> ma;
int dfs(TreeNode* n,int a,int b)
{
	if (n == NULL)return 0;
	if (n->val == a )ma[a]++;
	if (n->val == b )ma[b]++;

		int g = ma[n->val] + dfs(n->left, a, b) + dfs(n->right, a, b);
		if (f==-1 && g >= 2)
		{
			f = n->val;
		}
	return g;
}
int f = -1;
int lowestCommonAncestor(TreeNode* root, int o1, int o2) {
	dfs(root, o1, o2);
    return f;

}
};

实现二叉树先中后序排列

难度：middle

考察次数：97

传送门

题目描述
分别按照二叉树先序，中序和后序打印所有的节点。

思路： 深度优先搜索，先序遍历即每到一个节点优先访问当前的节点值，后续遍历最后访问当前节点值，中序遍历先访问左节点再访问当前节点值最后访问右节点。

AC code

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */
#include<stack>

class Solution {
public:
    /**
     * @param root TreeNode类 the root of binary tree
     * @return int整型vector<vector<>>
     */
    int lst[4][100005];
    int g[4];
    void preorder(TreeNode *p)
    {
        if(p==NULL)return;
        lst[1][++g[1]]=p->val;
        preorder(p->left);
        preorder(p->right);
    }
    void pastorder(TreeNode *p)
    {
        if(p==NULL)return;
        pastorder(p->left);
        pastorder(p->right);
        lst[3][++g[3]]=p->val;
    }
    void inOrder(TreeNode* p)
    {
        if(p==NULL)return;
        inOrder(p->left);
        lst[2][++g[2]]=p->val;
        inOrder(p->right);
    }
    vector<vector<int> > threeOrders(TreeNode* root) {
        // write code here
        g[1]=0,g[2]=0,g[3]=0;
        preorder(root);
        
        inOrder(root);
        
        pastorder(root);
            
        vector<vector<int>> ans;
        
        for(int i=1;i<=3;i++)
        {
            vector<int> vec;
            for(int j=1;j<=g[i];j++)vec.push_back(lst[i][j]);
            ans.push_back(vec);
        }
        return ans;
    }
};

二叉树之字形遍历

难度：middle

考察次数：37

传送门

题目描述
给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）
例如：
给定的二叉树是{3,9,20,#,#,15,7},

该二叉树之字形层序遍历的结果是

[
[3],
[20,9],
[15,7]
]

思路： 每次遍历一层的节点保存到一个列表中，然后下一层要从相反方向遍历，那么只需从当前层的后面往前面遍历子节点即可（每个下一层都是前一层的相反方向就实现了之字形遍历了），还要注意每次到新的一层要改变一下遍历方向，比如这层先遍历左节点再右节点，下层先右节点再左节点。

AC code

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > zigzagLevelOrder(TreeNode* root) {
        // write code here
        vector<vector<int>> ans;
        if(root==NULL)return ans;
        vector<TreeNode*> vec,t;
        vector<int> lst{root->val};
        ans.push_back(lst);
        vec.push_back(root);
        
        int f=1;
        while(!vec.empty())
        {
           t.clear();
                for(int i=vec.size()-1;i>=0;i--)
                {
                    if(f==1)
                    {
                    if(vec[i]->right!=NULL)t.push_back(vec[i]->right);
                    if(vec[i]->left!=NULL)t.push_back(vec[i]->left);
                        
                    }
                    else
                    {
                    if(vec[i]->left!=NULL)t.push_back(vec[i]->left);
                    if(vec[i]->right!=NULL)t.push_back(vec[i]->right);
                        
                    }
                }
            vec=t;
            vector<int> tt;
            for(int i=0;i<vec.size();i++)tt.push_back(vec[i]->val);
            if(tt.size()==0)break;
            ans.push_back(tt);
            f=-f;
        }
        return ans;
    }
};

4.二分篇

求平方根

难度：easy

考察次数：27

传送门

题目描述
实现函数 int sqrt(int x).
计算并返回x的平方根（向下取整）

思路： 初始化l=0,r=x。直接暴力二分100次，mid=(l+r)/2，如果midmid<=x , l=x , 如果midmid>x ， r=mid。

AC code

class Solution {
public:
    /**
     * 
     * @param x int整型 
     * @return int整型
     */
    int sqrt(int x) {
        // write code here
        double l=0,r=x,m;
        int i=1;
        while(1)
        {
            if(++i>=500)break;
            m=(l+r)/2;
            if(m*m>=x)r=m;
            else l=m;
        }
        return floor(r);
    }
};

5.其他

岛屿数量

难度：middle

考察次数：24

传送门

题目描述

给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。
岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。

思路： 用一个book[i][j]记录之前有没有遍历过该处，然后把整个矩阵暴力dfs一遍，遇到lst[i][j]==1则dfs该处，如果该处四周的元素有值为1的，则接着dfs搜索下去每搜索一个地方记录。最后当全部都遍历一遍看需要从矩阵进入遍历几次即为岛屿数量。

AC code

class Solution {
public:
    /**
     * 判断岛屿数量
     * @param grid char字符型vector<vector<>> 
     * @return int整型
     */
    int book[505][505];
int x,y;
void dfs(int n,int m,vector<vector<char>> vec)
{
    if(book[n][m]||n<0||m<0||n>x||m>y)return;
    book[n][m]=1;
    if(n+1<=x&&vec[n+1][m]=='1')dfs(n+1,m,vec);
    if(n-1>=0&&vec[n-1][m]=='1')dfs(n-1,m,vec);
    if(m+1<=y&&vec[n][m+1]=='1')dfs(n,m+1,vec);
    if(m-1>=0&&vec[n][m-1]=='1')dfs(n,m-1,vec);
}
    int solve(vector<vector<char> >& grid) {
        // write code here
        x=grid.size()-1;
        y=grid[0].size()-1;
        int ans=0;
        for(int i=0;i<=x;i++)
            for(int j=0;j<=y;j++)
            {
                if(book[i][j]==0)
                {
                    if(grid[i][j]=='1')
                    {
                        dfs(i,j,grid);
                        ans++;
                    }
                }
            }
        return ans;
    }
};

最长无重复子串

难度：middle

考察次数：52

传送门

题目描述
给定一个数组arr，返回arr的最长无的重复子串的长度(无重复指的是所有数字都不相同)。

思路：尺取法，用两个坐标记录当前子串前后，每次将前面的坐标往前挪动一格，发现有重复的则将后面的坐标往前收缩直到无重复。

AC code

#include<map>
class Solution {
public:
    /**
     *
     * @param arr int整型vector the array
     * @return int整型
     */
    int maxLength(vector<int>& arr) {
        // write code here
        map<int,int> ma;
        int sum=0;int j=0;
        int ans=0;
        for(int i=0;i<arr.size();i++)
        {
            ma[arr[i]]++;
            if(ma[arr[i]]>=2)sum++;
            while(sum!=0)
            {
                int t=arr[j];
                ma[arr[j++]]--;
                if(ma[t]==1)sum--;
             }
             
            ans=max(ans,i-j+1);
             
        }
        return ans;
    }
};

括号生成

难度：middle

考察次数：13

传送门

题目描述
给出n对括号，请编写一个函数来生成所有的由n对括号组成的合法组合。
例如，给出n=3，解集为：
“((()))”, “(()())”, “(())()”, “()()()”, “()(())”,

思路：回溯+剪枝，用一个open代表左括号，close代表右括号，然后dfs遍历所有情况，细节见代码。

AC code

class Solution {
public:
    /**
     * 
     * @param n int整型 
     * @return string字符串vector
     */
    vector<string> ans;
    int len;
    void solve(int open,int close,string str)
    {
        if(str.size()==2*len)ans.push_back(str);
        if(open<len)solve(open+1,close,str+"(");
        if(close<open)solve(open,close+1,str+")");
    }
    vector<string> generateParenthesis(int n) {
        len=n;
        solve(0,0,"");
        return ans;
    }
};

有重复数字的所有排列

难度：middle

考察次数：11

传送门

题目描述
给出一组可能包含重复项的数字，返回该组数字的所有排列。

思路：回溯，标记好哪个数字被使用与否，暴力dfs，用一个map记录出现过的排列。

AC code

class Solution {
public:
    int b[10005],n;
    vector<vector<int>> ans;
    vector<int> lst;
    map<vector<int>,int> ma;
    void solve(vector<int> vec,int h)
    {
        if(h==n)
        {
            if(ma[vec]==0)
            {ans.push_back(vec);ma[vec]++;}
            
            return;
        }
        for(int i=0;i<=n-1;i++)
        {
            if(b[i]==0)
            {
                vector<int> t;
                t=vec;
                vec.push_back(lst[i]);
                b[i]=1;
                solve(vec,h+1);
                b[i]=0;
                vec=t;
                
            }
        }
    }
    vector<vector<int> > permuteUnique(vector<int> &num) {
        n=num.size();
        lst=num;
        vector<int> ss; 
        solve(ss,0);
        return ans;
    }
};
_Rikka_
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
大厂算法面试题库中高频出现的30道典型题
04-09
大厂算法面试题库中,高频出现的30道典型题
面试高频算法题
技术原始积累
04-06 421
近年来算法在大厂面试中几乎是必问的，特别是字节跳动和快手，其技术三轮面试都会在每轮面试最后出一道算法题，虽然有些公司算法在整个面试分数中占比不是很高，但是如果算法过了，无疑是加分项。而...
30 道高频算法面试题
算法channel
06-17 899
振哥和很多读者有过交流，其中不乏工作党，他们都一致认为算法能力对于工作至关重要。其中一些读者一直期望从软开转算法岗，但是苦于找不到方向，事倍功半。我的很多算法同行，都坚定认为算法刷题很重...
高频算法面试题学习总结----图形结构1：克隆图
Moyu的专栏
02-17 250
题目：克隆一个无向图。 输入： node = {{1, 2}, {0}, {0, 2}} 解释： 0 / \ 1 2 /\ \/ 输入有三个节点，第0个节点和第1个和第2个节点相连，第1个节点和第0个节点相连， 第2个节点 和第0个、第2个节点相连。 输出：{{1, 2}, {0}, {0, 2}} 解释：输出的结构相同，但是节点不一样。 题目解读： 如图1所示，题目利用二维...
面试中的高频特色算法题（持续更新中）
少年锦时
08-20 724
记录找工作的过程中遇到的和看别人面经过程中看到的比较有意思的面试题。 ———————————————————————————————————————————— 一、排序 1、快排   快排的基本思想是分治，每次选取一个基准元素，把大于该元素值的所有数据移到一遍，小于其的移到另一边，然后递归对左右两边元素执行相同排序操作。   （1）不用递归去实现快排，这种情况下，可以采用一个辅助栈保存需
网络互动练习 原来可以这样简单——Hot Potatoes在英语Web试题制作中的应用.pdf
01-02
Hot Potatoes包含JQuiz(创建多选题或简答题练习)、JCloze(创建填空题练习)、JMatch(创建配对题练习)、JMix(创建组句题练习)、JCROSS(创建纵横填字谜)、The Masher(组合各类练习题)等模块。 使用Hot Potatoes制作...
11.Webpack面试真题-59页.pdf
02-28
根据提供的文件信息，我们可以归纳出一系列与前端开发相关的知识点，特别是关于Webpack的使用与面试准备。下面将逐一解析这些知识点： ### Webpack基础知识 #### 1. Webpack概述 - **定义**：Webpack是一款用于...
Vue.js中的高级面试题及答案
11-27
以下是一些关于 Vue.js 高级面试题及其答案的详细解释： 1. **Vue-loader 和 Webpack 的关系** Vue-loader 是 Webpack 的一个插件，专门处理 Vue 单文件组件（Single File Components，SFCs）。SFC 包含模板、脚本...
前端面试题之webpack相关题集.zip
最新发布
06-21
这个压缩包文件“前端面试题之webpack相关题集.zip”显然包含了针对 Webpack 的面试问题集合，旨在帮助开发者准备相关的面试。 Webpack 的核心概念主要包括： 1. **入口（Entry）**：这是构建流程的起点，定义了...
java笔试题算法-Java-BackEnd-Notes:Java后端技术春招秋招面试必备基础知识
06-03
java笔试题算法  算法  操作系统  网络  面向对象  数据库   Java  系统设计  工具  编码实践  框架  Other languages: :pencil: 算法 :cloud: 网络 :hot_beverage: Java Java面经（含有解答） :laptop:...
大厂算法面试题库中高频出现的30道典型题.pdf
04-29
大厂算法面试题，高频出现的30题，面试绝对有用。如果你刷leetcode题目很多，为了面试不如看看高频题，这30到够用了，经常会被笔试到，资料很好。
面试高频算法题目
qq_35515283的博客
01-06 192
二叉树： NC45实现二叉树先序，中序和后序遍历 public class Solution { /** * * @param root TreeNode类 the root of binary tree * @return int整型二维数组 */ public int[][] threeOrders (TreeNode root) { //三个集合，分别存储三种遍历结果 List<Integer>.
高频算法题（面试前刷，持续更新）
weixin_43744732的博客
04-02 1008
面试高频算法 704. 二分查找 难度简单585收藏分享切换为英文接收动态反馈 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 示例 1: 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 示例 2: 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释
高频算法面试真题
m0_59529616的博客
08-03 135
★★★ 冒泡排序 ★★ 选择排序 ★★ 插入排序 ★★ 希尔排序 ★★ 归并排序 ★★★ 快速排序 ★★ 堆排序 ★★★ 斐波那契数列 ★★ 汉诺塔问题 ★★ 合并两个有序数组 ★★ 数组中重复的数字 ★★ 两个数组的交集 ★★ 旋转数组 ★★ 两数之和 ★★ 爬台阶的实现思路 高频算法面试真题 ★★★ 冒泡排序 从开始位置两两比较，持续n轮 基础版 function bubbleSort (arr) { // 执行第 i + 1 轮 for (let
❤️ 互联网大厂面试高频算法题汇总 ❤️ —— ❤️ 二分专场 (一) ❤️
热门推荐
林深不见鹿 的博客
08-25 2万+
文章目录1、前言2、题目汇总3、二分模板4、二分流程5、二分高频题详解5.1、LeetCode 33. 搜索旋转排序数组5.2、LeetCode 704. 二分查找5.3、LeetCode 69. x 的平方根5.4、LeetCode 4. 寻找两个正序数组的中位数5.5、LeetCode 153. 寻找旋转排序数组中的最小值5.6、LeetCode 162. 寻找峰值5.7、LeetCode 34. 在排序数组中查找元素的第一个和最后一个位置 1、前言 二分查找也称折半查找（Binary Search
查找不含有重复字符的最长子串的长度
weixin_44783458的博客
12-07 470
给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。 public static int lengthOfLongestSubstring(String s) { int rs = 0; int[] last = new int[128]; for (int i = 0; i < 128; i++) { last[i] = -1; } int start = 0; for
高频算法面试题总结
wwxy1995的博客
07-23 334
算法题：买卖股票的最佳时机（只能有一次买卖，可以最多两次买卖，不限次数）（4） 只能买一次和无穷次简单，两次以及k次困难 算法题(leetcode55题)：给一个数组，例如[1,2,3,4,5]，a[i]表示在该位置可以向前行走的最大距离，判断是否可以到达数组的最后一个元素。 贪心，维护一个变量，表示当前可以跳到的最远距离 class Solution { public: bool canJump(vector<int>& nums) { int ma...
程序员面试高频算法题
jiyanfeng1的专栏
11-20 1203
0. 请计算x的二进制表示中1的个数；计算x按比特左右反转的数；计算x使得当a=0时x=y，否则x=z；计算x的平方根……但是都不许用if、while、do-while、?:表达式，也不许用&&和||这两个运算符，不许调用子函数。     应用：一些计算密集型的算法对分支很敏感，分支预测失败，就会浪费很多时间。if/while/do-while/?:以及短路运算符一般都是用控制流实现的。
最新面试高频算法题
wwxy1995的博客
08-24 431
3.100亿url，怎么看某个url已经存在（手写一个布隆过滤器即可） 4.100亿url，怎么求TopK（hash，然后小根堆） 6.算法:判断—棵二叉树是否是对称的 7.算法:有若干[30,50,100]优惠券，求给定一个数值求最优的方案。例如∶价格是40=>[30]80 =>[30，50].110=>[30,30,50] （dp） Leetcode 1419 数青蛙 4.算法:最长合法的括号匹配 （Leetcode原题） 1. 字符串中数字位置...
np怎么one——hot
08-29
对于NLP（自然语言处理）中的One-hot编码，可以使用以下方式进行操作： 1. 首先，确定需要进行编码的词汇表大小（即词汇表中不同单词的数量）。 2. 创建一个大小为词汇表大小的零向量（全零向量）。 3. 对于每个...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_Rikka_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值