中大厂前端面试常考算法

2022.3.29 更新
基本都是力扣上的简单、中等题，有精力的话可以寻求更好的方法。以下题目都是笔者面中大厂的亲身经历

快速排序（腾讯）

// 最基础的方法，很直观，还有更好的方法
function quickSort (arr) {
	if (arr.length <= 1) return arr // 递归判断结束
    let index = Math.floor(arr.length / 2) // 取中间数索引
    let center = arr.splice(index, 1)[0] // 取索引对应元素并将其从原数组中删除
    let left = [], right = [] // 定义两个数组（左&&右）
    for (let i = 0; i < arr.length; i++) {
    	// 遍历数组，若小于中间数则放入左数组，反之右数组
    	arr[i] < center ? left.push(arr[i]) : right.push(arr[i])
    }
    // 递归，将所有数组合并
    return quickSort(left).concat([center], quickSort(right))
}

爬楼梯（腾讯）

// 题目描述：假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
// 注意：给定 n 是一个正整数。

// 方法一：递归是可以的，不过时间复杂度有点高

// 方法二：动态规划，简单明了
var climbStairs = function (n) {
	let p = q = 0
	let result = 1
	for (let i = 1; i <= n; i++) {
		p = q
		q = result
		result = p + q
	}
	return result
}

两数之和（阿里）

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

// 方法一：双循环暴力枚举，类似冒泡排序的思想，很容易想到，不建议

// 方法二：hash 表存值，一个for循环搞定
var twoSum = function (nums, target) {
	if (!nums) return []
	// 创建 Map 对象
	const m = new Map()
	for (let i = 0; i < nums.length; i++) {
		let key = nums[i] // 遍历数组项
		let val = target - nums[i] // 计算数组项匹配的值
		// 如果 Map 对象里有匹配的值，返回对应的“两个”下标
		if (m.has(val)) return [m.get(val), i]
		m.set(key, i) // 否则存入该值
	}
}

字符串相加（腾讯）

// 题目描述：给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。
var addStr = function (nums1, nums2) {
	let i = nums1.length - 1, j = nums2.length - 1
	let add = 0, arr = []
	while (i >= 0 || j >= 0 || add != 0) {
		let x = i >= 0 ? nums1.charAt(i) - 0 : 0
		let y = j >= 0 ? nums2.charAt(j) - 0 : 0
		let result = x + y + add
		arr.push(result % 10)
		add = result / 10
		i--
		j--
	}
	return add.reverse().join(" ")
}

字符串内部排序（腾讯）

// 题目描述：字符串排序，str = "aa a bee dd ee" => str = "a aa bee ee dd"

考官给的结果：return str.split(" ").sort().join(" ") // 感觉本意不像考算法

版本号排序（字节、好未来）

// 输入输出
["1.45.1", "1.5.0"] => ["1.5.0", "1.45.1"]
["9.99.9", "10.1.0", "0.0.1"] => ["0.0.1", "9.99.9", "10.1.0"]

function sortVersions( versions ) {
    return versions.sort((a, b) => {
        let v1 = a.split("."), v2 = b.split("."), k = 0
        for (let i in v1) {
            let a1 = v1[i], a2 = v2[i]
            if (typeof a2 === undefined) {	
                k = 1
                break
            } else {
                if (a1 === a2) {
                    continue
                }
                k = Number(a1) - Number(a2)
                break
            }
        }
        return k
    })
}

返回字符串中出现次数最多的元素（好未来）

// 输入输出
"aaabbbb" => ["b", 4]

function getMaxLengthChar( str ) {
	let map = new Map(), max = 0, index = ''
    for (let i = 0; i < str.length; i++) {
    	if (!map.has(str[i])) {
      		map.set(str[i], 1)
    	} else {
      		map.set(str[i], map.get(str[i]) + 1)
    	}
  	}
  	for (let j = 0; j < str.length; j++) {
    	if (map.get(str[j]) > max) {
      		index = str[j]
      		max = map.get(str[j])
    	}
  	}
  	return [index, max]
}

小红书 2022.3.27 前端三道算法

简单得有点离谱

• 搜索字符串里只出现一次的数字：哈希表
• 搜索树里的叶子结点个数：递归，遍历树
• 搜索数组里只出现一次的数字：哈希表，和第一题基本一样

如果觉得对你有帮助的话，点个赞呗~

反正发文又不赚钱，交个朋友呗~

如需转载，请注明出处foolBirdd