leetcode 最常见的 150 道前端面试题（简单题上）

前言

本文题目选自 LeetCode 精选 TOP 面试题[1]，而这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。本文挑选其中所有简单题做归类和解法分析。后续更新所有中等题分析。

为了帮助大家快速刷题，通过将数据结构 + 题型的方式总结出来，比如说哈希表拥有记数的功能，如果题目中包含字眼至多xx次， 至少xx次,唯一等等字眼，可以联想到用哈希表来解决。刷个3-4道类似的题，就会养成一种条件反射。

举例：存在重复元素（类似题还有3道，后面一起说，解法一样）

---

题目描述如下：

给定一个整数数组，判断是否存在重复元素。

如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

示例 1:

输入: [1,2,3,1]

输出: true

示例 2:

输入: [1,2,3,4]

输出: false

这题一看就是 计数问题，题目中如果存在一值在数组中出现至少两次，这句话就告诉我们记录每一个数字出现的次数就能解决问题了。

解决思路：

我们遍历数组时，经过数组中的每一项就往map中添加，比如[1,2,3,1]

• 第一项：遍历到第一个1时，对象返回{ 1: 1 },代表1出现1次

• 第二项：遍历到2时，返回 { 1: 1, 2: 1 }

• 第三项：遍历到3时，返回 { 1: 1, 2: 1， 3: 1 }

• 第四项：遍历到第二个1时，发现原来的对象里已经有1了，返回false

所以，代码自然也就出来了，如下：

const containsDuplicate = function(nums) {

let map = new Map();

for(let i of nums){

if(map.has(i)){

return true;

}else{

map.set(i, 1);

}

}

return false;

};

哈希表 + 计数类型

---

除了上面的那道题，在最热门的简单题型中还有一些记数类型的题，我们一一解答，这是一类题型

387. 字符串中的第一个唯一字符

---

一看题目，唯一，条件反射，记数题啊，map走起！我们先看一下题目：

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

示例：

s = “leetcode”

返回 0

s = “loveleetcode”

返回 2

// 提示：你可以假定该字符串只包含小写字母

复制代码

思路：

• 遍历字符串

• 用一个对象{}来记数，出现过一次就+1，

• • 遍历完毕，再次遍历字符串，看它们在之前记录的对象里的值，是否是1，是就返回下标，不是返回-1。

参考答案：

var firstUniqChar = function(s) {

const map = {};

for(let v of s) map[v] = (map[v] || 0) + 1;

for(let i = 0; i < s.length; i++) if(map[s[i]] === 1) return i;

return -1;

};

242. 有效的字母异位词

---

我们先看一下题目：

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”

输出: true

示例 2:

输入: s = “rat”, t = “car”

输出: false

思路：这个题一看字眼，出现次数相同，次数不就是记数吗，记数题型，map走起！

• 声明计数器，一个对象 const obj = {}

• 遍历s字符串，如果遍历到字符串的'a'字母，去看obj[a]是否存在

• 不存在说明第一次遍历到'a'字母，那么初始化obj[a] = 1

• 如果存在则obj[a] += 1

• t字符串同理，它每次减1

• 遍历完s字符串后，遍历obj对象，看它的每一对key：value，是否value都是0

var isAnagram = function(s, t) {

const sLen = s.length;

const tLen = t.length;

if(sLen !== tLen ) {

return false;

}

const obj = {};

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

const currentS = s[i];

const currentT = t[i];

obj[currentS] ? obj[currentS]++ : obj[currentS] = 1;

obj[currentT] ? obj[currentT]-- : obj[currentT] = -1;

}

return Object.values(obj).every(v=>v===0);

};

169. 多数元素

---

我们先看题目（题目里有次数两个字，又是记数题型，map继续走起）：

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：

输入：[3,2,3]

输出：3

示例 2：

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

输出：2

思路：

• 声明一个计数器,也就是一个对象const map = {}

• 遍历字符串，开始记数，如果字符串的字母第一次碰见，map[第一次碰见的字母] = 1

• 如果map已经记录过这个字母，则map[记录过的的字母] += 1

• 在遍历的过程中，看map[记录过的的字母] 是否大于 数组总长度/2

解答：

var majorityElement = function(nums) {

const map = {}

const n = nums.length >> 1 // >>是右移运算符，意思是除以2

for(let i = 0; i < nums.length; i++){

map[nums[i]] = map[nums[i]] !== undefined ? map[nums[i]] + 1 : 1

if(map[nums[i]] > n) return nums[i]

}

}

只出现一次的数字

---

这个题一看，出现一次，map走起，但是呢，这个题比较巧的是，因为题目的一些限制条件，可以有更好的解法，我们先看题：

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]

输出: 1

示例 2:

输入: [4,1,2,1,2]

输出: 4

这里我们用map记录一遍，类似这样的代码，

const countMap = {};

数组.forEach((item)=> { countMap[item] ? countMap[item] += 1 : countMap[item] = 1 } )

最后再遍历一次countMap，然后看谁的次数是1，就解决了

但是这套题有另一个解法，用异或运算符，首先我们看看异或运算符有啥用：

异或运算符(^)，我们了解下，这个运算符的功能

• 任何数和自己做异或运算，结果为 0，即 a⊕a=0。

• 任何数和 0 做异或运算，结果还是自己，即 a⊕0=a。

• 异或运算中，满足交换律和结合律，也就是a⊕b⊕a=b⊕a⊕a=b⊕(a⊕a)=b⊕0=b。

所以出现两次的字母异或运算得0，跟出现一次的字母异或运算得到自己

解答：

var singleNumber = function(nums) {

let init = nums[0];

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

init ^=  nums[i];

}

return init;

};

位1的个数

---

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

示例 1：

输入：00000000000000000000000000001011

输出：3

解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1’。

示例 2：

输入：00000000000000000000000010000000

输出：1

解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1’。

思路：

计算个数，按照我们之前的思路，把整个数字转为字符串，类似这样：

数字 0001 => String(0001) => ‘0001’ => 遍历看1的个数

然后直接遍历计算就可以了，这是我为什么把它归为记数类别的原因，当然也可以把它归为数学类，我们用数学的算法来解，先看答案，我们再解析。

var hammingWeight = function(n) {

let ret = 0;

while(n){

n &= (n - 1);

ret++;

}

return ret;

};

原理：

每执行一次x = x & (x-1)，会将x用二进制表示时最右边的一个1变为0，因为x-1将会将该位(x用二进制表示时最右边的一个1)变为0。因此，对 x 重复该操作，直到 x 变成 0，则操作次数即为 x 的二进制数中的 1 的数目。

接下来，我们把其他类型的哈希表题也介绍了（相同的题型没那么多）

哈希表 + 映射功能

---

哈希表有一个非常常见的功能就是建立映射关系，比如说设计模式里的策略模式，思路是一样的，映射表常常见于后端的枚举类型，typescript也是一样，我们举一个js的例子

// 后端只会返回0，1，2

const TYPE = {

2: ‘orange’,

1: ‘red’,

0: ‘blue’

}

// 然后前端会这样用

TYPE[后端返回的数字0或1或2]

对应的题有：

• 1.两数之和

• 349.两个数组的交集

两数之和

---

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9

输出：[0,1]

解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6

输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6

输出：[0,1]

用 hashMap 存储遍历过的元素和对应的索引。每遍历一个元素，看看 hashMap 中是否存在满足要求的目标数字。所有事情在一次遍历中完成（用了空间换取时间）

var twoSum = function(nums, target) {

const map = new Map();

for(let i = 0, len = nums.length; i < len; i++){

if(map.get(nums[i]) !== undefined){

return [map.get(nums[i]), i];

} else {

map.set(target - nums[i], i);

}

}

return [];

};

两数组交集

---

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

示例 1：

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

输出：[2]

示例 2：

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

输出：[9,4]

说明：

输出结果中的每个元素一定是唯一的。

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

这道题可以用set，很简单,但是空间复杂度和时间复杂度都太高，不太优雅

var interp = function (nums1, nums2) {

return result =[…new Set(nums1)].filter(item=>new Set(nums2).has(item))

};

我们可以用map来做，时间和空间复杂度都低很多 思路：

• 用一个map去存nums1数组里的每一项，类似map[nums1[i]] = true

• 然后去遍历nums2，如果在map中已经有的值，类似map[nums2[i]], 就把它push到一个数组里

• 并且将map[nums2[i]]设为false，后面有相同的值就不push到数组了

var interp = function(nums1, nums2) {

const map = {};

const ret = [];

for(let i = 0; i < nums1.length; i++){

map[nums1[i]] = true;

}

for(let i = 0; i < nums2.length; i++){

if(map[nums2[i]]){

ret.push(nums2[i])

map[nums2[i]] = false

}

}

return ret;

};

找规律题

---

这类题一般画个图或者稍微分析一下就能得出答案

13. 罗马数字转整数

---

这个题，我来简单描述一下，罗马数字对应我们阿拉伯数字的map如下：

I: 1,

V: 5,

IV: 4,

IX: 9,

X: 10,

XL: 40,

XC: 90,

L: 50,

C: 100,

CD: 400,

CM: 900,

D: 500,

M: 1000,

题目是给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: “III”

输出: 3

示例 2:

输入: “IV”

输出: 4

示例 3:

输入: “IX”

输出: 9

示例 4:

输入: “LVIII”

输出: 58

解释: L = 50, V= 5, III = 3.

解题思路就是我们发现这些案例的规律，就是把map表里面对应数字加起来就行了，比如说

"LVIII" = 'L'（对应map表50）+ 'V'（对应map表5）+ 'I'（对应map表1） + 'I'对应map表1） + 'I'（对应map表1）

所以解答就很简单了，就是遍历数字把对应的值加起来，如下：

var romanToInt = function(s) {

const map = {

I: 1,

V: 5,

IV: 4,

IX: 9,

X: 10,

XL: 40,

XC: 90,

L: 50,

C: 100,

CD: 400,

CM: 900,

D: 500,

M: 1000,

}

let res = 0;

let index = 0;

let len = s.length;

while(index < len){

if(index + 1 < len && map[s.slice(index, index+2)]){

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

index += 2;

}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

最后

今天的文章可谓是积蓄了我这几年来的应聘和面试经历总结出来的经验，干货满满呀！如果你能够一直坚持看到这儿，那么首先我还是十分佩服你的毅力的。不过光是看完而不去付出行动，或者直接进入你的收藏夹里吃灰，那么我写这篇文章就没多大意义了。所以看完之后，还是多多行动起来吧！

可以非常负责地说，如果你能够坚持把我上面列举的内容都一个不拉地看完并且全部消化为自己的知识的话，那么你就至少已经达到了中级开发工程师以上的水平，进入大厂技术这块是基本没有什么问题的了。

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】