leetcode 最常见的 150 道前端面试题（简单题上）(1)，哔哩哔哩面试题目

m0_60635609

已于 2024-04-14 02:58:12 修改

阅读量518

点赞数 14

分类专栏： 2024年程序员学习文章标签： leetcode 前端面试

于 2024-04-14 02:58:10 首次发布

本文链接：https://blog.csdn.net/m0_60635609/article/details/137731426

版权

2024年程序员学习专栏收录该内容

290 篇文章 1 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Web前端全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024c （备注前端）

正文

}else{

res += map[s.slice(index, index+1)];

index += 1;

}

return res;

};

14. 最长公共前缀

题目如下：

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1：

输入：strs = [“flower”,“flow”,“flight”]

输出：“fl”

示例 2：

输入：strs = [“dog”,“racecar”,“car”]

输出：“”

解释：输入不存在公共前缀。

提示：

0 <= strs.length <= 200

0 <= strs[i].length <= 200

strs[i] 仅由小写英文字母组成

复制代码

思路：这个题的思路就是，假如你求数组里3个元素的最长公共前缀

你先拿前两个比较，求出他们两个的最长公共前缀
然后上面求出的结果去跟第三个元素求最长公共前缀
n个元素就一直这么reduce下去

// 这个是求出两个元素最长公共前缀的方法

var longestCommonPrefix = function (strs) {

if (strs.length === 0) return ‘’

if (strs.length === 1) return strs[0];

return strs.reduce(getSameStr, strs[0]);

};

function getSameStr(a, b) {

let res = ‘’

for (let j = 0; j < a.length; j++) {

if (a[j] === b[j]) {

res += a[j];

} else {

return res;

}

return res

}

复制代码

21. 合并两个有序链表

这个题简而言之就是看图找规律，就是合并为升序链表，具体题目如下：

我们先看一下题目：

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

image.png

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]

输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []

输出：[]

示例 3：

输入：l1 = [], l2 = [0]

输出：[0]

提示：

两个链表的节点数目范围是 [0, 50]

-100 <= Node.val <= 100

l1 和 l2 均按非递减顺序排列

复制代码

思路:

那就挨个遍历，按顺序谁小拼接谁，接着进入下一轮循环，看代码更清晰一些：

// 链表定义函数

function ListNode(val, next) {

this.val = (val===undefined ? 0 : val)

this.next = (next===undefined ? null : next)

}

var mergeTwoLists = function(l1, l2) {

const dummpy = node = new ListNode();

while(l1 && l2){

if(l1.val >= l2.val){

node.next = l2;

node = node.next;

l2 = l2.next;

} else {

node.next = l1;

node = node.next;

l1 = l1.next;

}

node.next = l1 || l2;

return dummpy.next;

};

复制代码

28. 实现str（）

题目如下：

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

示例 1：

输入：haystack = “hello”, needle = “ll”

输出：2

示例 2：

输入：haystack = “aaaaa”, needle = “bba”

输出：-1

示例 3：

输入：haystack = “”, needle = “”

输出：0

提示：

0 <= haystack.length, needle.length <= 5 * 104

haystack 和 needle 仅由小写英文字符组成

复制代码

思路：

本来这道题最佳算法是KMP，这个算法理解起来对我来说有难度，所以自己换了另一种思路

遍历字符串看是否有和需要找的字符串第一个字母相同
如果相同，就截取字符串跟需要找的字符串相同长度的字符串对比
相同就返回下标，不同就继续遍历原字符串

var strStr = function (haystack, needle) {

if (needle === “”) return 0

for (var i = 0; i < haystack.length; i++) {

if (haystack[i] === needle[0]) {

if (haystack.substring(i, i + needle.length) === needle) return i;

}

return -1

};

复制代码

118. 杨辉三角

这个可是找规律的代表题，并且这道题可以训练一下你对二维数组 转化为 代码的能力：

给定一个非负整数 numRows， 生成杨辉三角的前 numRows 行。

image.png

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 5

输出:

[

[1],

[1,1],

[1,2,1],

[1,3,3,1],

[1,4,6,4,1]

]

复制代码

思路：

看到上图可以发现，生成杨辉三角numRows行，数组就有numRows行
每一行，它的数组第一个位置和最后一个位置都是1
每一行，除了第一个和最后一个位置，其它位置的值等于上一行的两个值相加

把思路翻译成代码即可：

var generate = function(numRows) {

if(numRows === 0){ return [] }

const result = Array.from(new Array(numRows), ()=>[])

for(let i = 0; i < numRows; i++){

result[i][0] = 1; result[i][i] = 1;

for(let j = 1; j < i; j++){

result[i][j] = result[i-1][j-1] + result[i-1][j]

}

return result

};

复制代码

121. 买卖股票的最佳时机

接下来这道题，你简单看下题目就行，解答原理超级简单，看图说话，找规律！

我们先看题：

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天买入这只股票，并选择在未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]

输出：5

解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。

注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]

输出：0

解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

提示：

1 <= prices.length <= 105

0 <= prices[i] <= 104

复制代码

解题思路：我们先看一张图，假设给定的数组为：[7, 1, 5, 3, 6, 4]

image.png

第一天是7，我们记录一下，因为还没到第二天不知道这个价格是高是低，标记最小值是7
第二天是1，比7小，那么只要当前天数的值比前面小，就说明不卖，因为它是最小值，标记最小值是7
第三天是5，5比前一天大，说明比最小值要大，那么可以卖，利润就是5-1=4
第四天发现是3，比5小，还是一样的道理，比之前小，最小值就要变为当前值，啥也不干，标记最小值是3
第五天发现是6…，第六天发现是4，规律是一样的

意思是只要今天比昨天低，就可以用今天的减去最小值，就是利润，然后每次都比较这个利润是不是最大就行了

结合一下代码，就会清楚

var maxProfit = function(prices) {

let res = 0;

let min = prices[0];

for(let i = 1; i < prices.length; i++){

if(prices[i] < min){

min = prices[i]

} else {

res = Math.max(res, prices[i] - min)

}

return res;

};

复制代码

122. 买卖股票的最佳时机2

又来一道看图说话题目，简单！走起！

先看题目：

给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: prices = [7,1,5,3,6,4]

输出: 7

解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。

随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

示例 2:

输入: prices = [1,2,3,4,5]

输出: 4

解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。

注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:

输入: prices = [7,6,4,3,1]

输出: 0

解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

复制代码

思路，看图马上思路就出来了：

我们的利润就跟上图绿色部分显示的一样，也就是说只要今天减去昨天，是正数就是利润，简单吧，哈哈！

var maxProfit = function(prices) {

let result = 0

for(let i = 1; i < prices.length; i++){

if(prices[i] > prices[i-1]){

result += prices[i] - prices[i - 1]

}

return result

};

复制代码

206. 反转链表

这个题必须掌握牢实，是解很多链接表题的基础的基础。先看题目：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

image.png

输入：head = [1,2,3,4,5]

输出：[5,4,3,2,1]

复制代码

示例 2：

image.png

输入：head = [1,2]

输出：[2,1]

复制代码

解题思路依然是看图找规律，下图就是，我们把链表前面加一个null，这样翻转前和翻转后就一致了。解答：

var reverseList = function(head) {

let [pre, node] = [null, head];

while(node){

const temp = node.next;

node.next = pre;

pre = node;

node = temp;

}

return pre;

};

复制代码

双指针

双指针是解数组类型题最常见解法

比如有头尾分别有指针，然后依次向中间靠拢的双指针，
还有一种是快慢是指针，两个指针都是从左边开始，一个走的快，一个走得慢

具体的细节还是需要从题里体会，我们现在就开始！

26. 删除数组中的重复项

先看一下题目：

给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1：

输入：nums = [1,1,2]

输出：2, nums = [1,2]

解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]

输出：5, nums = [0,1,2,3,4]

解释：函数应该返回新的长度 5 ，并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

0 <= nums.length <= 3 * 104

-104 <= nums[i] <= 104

nums 已按升序排列

复制代码

初始状态是：

image.png

慢指针是i，快指针是j
如果nums[i] 等于 nums[j] 说明是相同的元素，j继续走，i还在原位
如果nums[i] 不等于 nums[j] 说明是不相同的元素，那么nums[i++] = nums[j]，j继续向前走

依次类推，就相当于i指针保证它和它前面的数字都是不重复的，j就是一个遍历器

var removeDuplicates = function(nums) {

let i = 0;

for(let j = 1; j < nums.length; j++){

if(nums[j] !== nums[i]){

nums[i+1] = nums[j];

i++

}

return i + 1

};

复制代码

88. 合并两个有序数组

我们先看题目：

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。

初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3

输出：[1,2,2,3,5,6]

示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0

输出：[1]

提示：

nums1.length == m + n

nums2.length == n

0 <= m, n <= 200

1 <= m + n <= 200

-109 <= nums1[i], nums2[i] <= 109

复制代码

这道题大家很容易想到，新创建一个数组，然后分别比较这两个数组里的每一项，push进去就行了

然而因为是有序数组，第一个数组还有正好满足假如第二数组的空间，所以这里可以采取双指针来解答，从后往前遍历

参考如下：

var merge = function (nums1, m, nums2, n) {

let len = m + n - 1;

m–, n–;

while (m >= 0 && n >= 0) {

if (nums1[m] > nums2[n]) {

nums1[len] = nums1[m–]

} else {

nums1[len] = nums2[n–]

}

len–;

}

if(m === -1){

return nums1.splice(0, len+1, …nums2.slice(0, n + 1));

}

if(n === -1){

return nums1;

}

};

复制代码

125. 验证回文串

请看题目：

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: “A man, a plan, a canal: Panama”

输出: true

解释：“amanaplanacanalpanama” 是回文串

示例 2:

输入: “race a car”

输出: false

解释：“raceacar” 不是回文串

复制代码

这个题太简单了，以至于不用写思路了，看代码就知道，就是用用双指针头尾向中间靠拢的解法，

var isPalindrome = function(s) {

s = s.replace(/[^\w]/g, ‘’).toLowerCase();

let leftPointer = 0;

let rightPointer = s.length - 1;

while(rightPointer > leftPointer){

if(s[leftPointer++] === s[rightPointer–]){

continue;

}else{

return false;

}

return true;

};

复制代码

234. 回文链表

这个题思路跟上面是一样的，都是双指针对比，但是主要这个题写起来很麻烦，要用到我们之前说的翻转链表，

解题思路：

先用快慢指针的手法，让我们知道这个链表的中点是哪，然后从中点截断
然后截断成为两个链表，把后面的链表翻转
最后依次去判断这两个链表每一项是否相同

关键点：如何从中点截断这个链表,方法如下，让一个指针每次走一步，另一个指针每次走两步，这样他们每次走的倍数就相差2倍。代码如下：

let fast = head;

let slow = head;

let prev;

while (fast && fast.next) {

prev = slow;

slow = slow.next;

fast = fast.next.next;

}

prev.next = null; // 断成两个链表

接着我们需要翻转链表

// 翻转后半段

let head2 = null;

while (slow) {

const tmp = slow.next;

slow.next = head2;

head2 = slow;

slow = tmp;

}

最后对比就看下面具体代码了

const isPalindrome = (head) => {

if (head == null || head.next == null) {

return true;

}

let fast = head;

let slow = head;

let prev;

while (fast && fast.next) {

prev = slow;

slow = slow.next;

fast = fast.next.next;

}

prev.next = null; // 断成两个链表

// 翻转后半段

let head2 = null;

while (slow) {

const tmp = slow.next;

slow.next = head2;

head2 = slow;

slow = tmp;

}

// 比对

while (head && head2) {

if (head.val != head2.val) {

return false;

}

head = head.next;

head2 = head2.next;

}

return true;

};

237. 删除链表中的节点

题目如下：

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为要被删除的节点。

现有一个链表 – head = [4,5,1,9]，它可以表示为:

image.png

示例 1：

输入：head = [4,5,1,9], node = 5

输出：[4,1,9]

解释：给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2：

输入：head = [4,5,1,9], node = 1

输出：[4,5,9]

解释：给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

提示：

链表至少包含两个节点。

链表中所有节点的值都是唯一的。

给定的节点为非末尾节点并且一定是链表中的一个有效节点。

不要从你的函数中返回任何结果。

这个题很简单，其实这个node是个引用类型，你只需要把node的val变为node.next的val，然后node的next指向node.next.next，就移花接木，完成任务了！自己可以试着在草稿上画一下，结合代码很快就会明白！

var deleteNode = function(node) {

node.val = node.next.val

node.next = node.next.next

};

283. 移动零

题目如下：给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]

输出: [1,3,12,0,0]

说明:

必须在原数组上操作，不能拷贝额外的数组。

尽量减少操作次数。

如动画所示，我们可以用快慢指针来解答，具体不好用语言叙述，看动图

show

var moveZeroes = function(nums) {

let i = j = 0;

while(i < nums.length) {

if(nums[i] !== 0){

[nums[i], nums[j]] = [nums[j], nums[i]]

j++

}

i++

}

return nums

};

344. 反转字符串

题目如下：

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：[“h”,“e”,“l”,“l”,“o”]

输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：

输入：[“H”,“a”,“n”,“n”,“a”,“h”]

输出：[“h”,“a”,“n”,“n”,“a”,“H”]

这个题目实在太简单了，知道用首位双指针即可，看参考：

var reverseString = function(s) {

let l = 0 ;

let r = s.length - 1;

while(l < r){

[s[l], s[r]] = [s[r], s[l]];

l++; r–;

}

return s;

};

350. 两个数组的交集II

题目如下：给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]

输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]

输出：[4,9]

说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。

我们可以不考虑输出结果的顺序。

这个取交集需要保留重复元素，可以是用双指针来解答，具体思路和代码如下

如果两个数组是有序的，则可以使用双指针的方法得到两个数组的交集。
首先对两个数组进行排序，然后使用两个指针遍历两个数组。
- 初始时，两个指针分别指向两个数组的头部。每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位，如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束

var intersect = function(nums1, nums2) {

nums1 = nums1.sort((a, b) => a - b);

nums2 = nums2.sort((a, b) => a - b);

let l1 = 0;

let l2 = 0;

const nums1Len = nums1.length;

最后

一个好的心态和一个坚持的心很重要，很多冲着高薪的人想学习前端，但是能学到最后的没有几个，遇到困难就放弃了，这种人到处都是，就是因为有的东西难，所以他的回报才很大，我们评判一个前端开发者是什么水平，就是他解决问题的能力有多强。

分享一些前端面试题以及学习路线给大家

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注前端）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：[“h”,“e”,“l”,“l”,“o”]

输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：

输入：[“H”,“a”,“n”,“n”,“a”,“h”]

输出：[“h”,“a”,“n”,“n”,“a”,“H”]

这个题目实在太简单了，知道用首位双指针即可，看参考：

var reverseString = function(s) {

let l = 0 ;

let r = s.length - 1;

while(l < r){

[s[l], s[r]] = [s[r], s[l]];

l++; r–;

}

return s;

};

350. 两个数组的交集II

题目如下：给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]

输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]

输出：[4,9]

说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。

我们可以不考虑输出结果的顺序。

这个取交集需要保留重复元素，可以是用双指针来解答，具体思路和代码如下

如果两个数组是有序的，则可以使用双指针的方法得到两个数组的交集。
首先对两个数组进行排序，然后使用两个指针遍历两个数组。
- 初始时，两个指针分别指向两个数组的头部。每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位，如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束

var intersect = function(nums1, nums2) {

nums1 = nums1.sort((a, b) => a - b);

nums2 = nums2.sort((a, b) => a - b);

let l1 = 0;

let l2 = 0;

const nums1Len = nums1.length;