疫情期间, 很幸运地遇到公司裁员了, 因此有机会尝试一下去认真面试各大厂. 大厂常见的一个套路就是问一道或者两道算法, 作为基本能力的考察. 没有经历这种套路的时候, 可能内心有所忐忑. 自己肉身体验一番, 感觉难度没有想得那么大, 经过准备还是能顺利接住的. 下面是几个大厂的面试题记录及自己的解答.
1 腾讯
最长回文字符串
回文，是正读反读都能一样的字符串。例如“12321”，“abba”。现给一个字符串，找出其中长度最长的回文字符串。当存在长度一样的结果时，返回第一个结果。
解决思路: 1 判断回文字符串; 2 两层 for 循环, 寻找最长字符串; 3 循环处理接收的字符串. 代码如下:
def isHuiWen(str):
if not len(str):
return False
count = len(str)
if (count%2)==0:
mid=count//2
i=mid-1
j=mid
else:
mid=count//2
i=mid-1
j=mid+1
res = True
while i>=0 and jlen(res_str):
res_str = sub_str
return res_str
while True:
a = input()
res = get_max_str(a)
print(res)
2 网易
2.1 链表翻转？
解决方式1
class Node:
def __init__(self, value):
self.value = value
self.next = None
def reverse_node(n):
if not n:
retun None
pre = None
h = n
while h:
h2 = h.next
h.next = pre
pre = h
h = h2
return pre
解决方式2: 使用递归方式
def reverse_node(n):
# 递归实现
if not n.next:
return n
else:
last = rever_node(n.next)
n.next.next = n
n.next = None
return last
2.2 删除链表中倒数的某个节点
def del_node(node, n):
if not node:
return None
h1 = node
h2 = node
while n > 0:
h1 = h1.next
n -= 1
while h1.next:
h1 = h1.next
h2 = h2.next
h2.next = h2.next.next
return node
3 快手
字符串匹配。匹配字符串中：？表示一个字符；表示多个字符或者没有字符。给定一个匹配字符串和一个字符串，判断二者是否匹配。比如 输入“？a”和“ba”，返回True，输入“?a*”和“bb”，返回False 快手
解决方式, 采用递归的思想:
def find_match(str, exp):
# .代表一个
# * 代表前面有 0个 或者 多个
if len(str) == 0 and len(exp) == 0:
return True
if len(str) == 0:
if exp[0] == "*":
return True
else:
return False
if len(exp) == 0:
return True
if exp[0] == ".":
return find_match(str[1:], exp[1:])
elif exp[0] == "*":
return find_match(str, exp[1:])
elif exp[0] == str[0]:
return find_match(str[1:], exp[1:])
else:
return False
4 百度
4.1 链表成环判断?
def is_circle(node):
if not node:
return False
l1 = node
l2 = node
res = False
while l1.next != None and l2.next != None:
l1 = l1.next
if l2.next.next:
l2 = l2.next.next
if l1 == l2:
# print(l1.value, l2.value, sep="**")
res = True
break
return res
由链表成环判断, 能够延伸到寻找成环入口节点:
def get_circle_begin(node):
if not node:
return None
l1 = node
l2 = node
res = False
while l1.next != None and l2.next != None:
l1 = l1.next
if l2.next.next:
l2 = l2.next.next
if l1 == l2:
res = True
break
if res:
l1 = node
while l1.next != None and l2.next != None:
if l1 == l2:
return l1
l1 = l1.next
l2 = l2.next
return None
4.2 链表共同节点
def common_node(n1, n2):
if not n1 or not n2:
return
def get_length(node):
if not node:
return -1
count = 0
while node:
count += 1
node = node.next
return count
l1 = get_length(n1)
l2 = get_length(n2)
inter_count = l1 - l2
if inter_count > 0:
while l2:
if l1 == l2:
print(l1.value)
l2 = l2.next
else:
while l1:
if l1 == l2:
print(l1.value)
l1 = l2.next
5 京东
快排
def quick_sort(nums, left, right):
if left < right:
index = get_index(nums, left, right)
quick_sort(nums, left, index - 1)
quick_sort(nums, index + 1, right)
def get_index(nums, left, right):
base = nums[left]
i, j = left, right
while i < j :
'''直到不满足'''
while i < j and nums[j] > base:
j -= 1
nums[i] = nums[j]
while i < j and nums[i] < base:
i += 1
nums[j] = nums[i]
nums[i] = base
return i
以上的算法都是 python3 实现的, 使用 VSCode 进行 python3 编程, 感觉能很快上手. 而且机器学习库众多和上手简单的原因, 学习 python 的人越来越多了. 回到算法本身, 使用哪种语言实现都是一样的, 关键是解决的思路. 做算法是一个很有意思的过程, 就像在学校解决数学题一样, 能够忘我的投入时间, 而且解决出来后内心收获感很强. 一轮大厂的体验下来, 算法其实并不难, 用心从头到尾梳理一下数组\链表\树的问题, 基本能够hold大部分场景. 在一个有心前辈整理的算法项目中, 我加入了所有 python3 的实现: awesome-algorithm-question-solution. 希望能帮助到需要的朋友.