花生_TL007

这个屌丝很懒，什么也没留下！

热门标签

2022春招各大厂高频面试题汇总_力扣2022春招高频面试题

作者：花生_TL007 | 2024-03-21 20:03:17

踩

力扣2022春招高频面试题

原创微信公众号：【小鸿星空科技】

版权声明：原创不易，本文禁止抄袭、转载，侵权必究！

一、Python(后端/服务端/算法/测试开发)

主观题：

自我介绍
项目介绍，会针对细节提问
你的优势在哪里？
你的不足之处是什么？
你有哪些爱好？
项目中遇到过哪些问题，是怎么解决的呢？
有其他公司的Offer吗？
举例说出你的平衡能力
最近在看什么书？
毕业时间？
为什么投我们公司？
形容下自己
职业规划
反问环节

数据库：

关系型数据库和非关系型数据库的区别？
数据库左连接、右连接、内连接、外连接的区别？
数据库中怎样进行约束？
复杂查询SQL语句以及跨表查询
group by 和 order by 的区别？
何时建立索引？
MySQL和Redis的区别？
SQL中各数据类型占的字节是多少？
redis是如何实现分布式和缓存的？
四大范式联系及区别？
数据库容中灾备份方案有哪些？

Linux：

你常用的Linux指令有哪些？
怎样一行找到进程的pid并杀死？
怎样查看日志？
怎样查看系统资源？
怎样找到指定的文件？
怎样找到指定的文件？
怎样查看IP地址？

计算机网络

http原理，和https有什么区别？
Get请求和Post请求的区别？
session和cookies有哪些区别？
TCP和UDP以及它们之间的区别
输入一个URL然后回车发生了什么？
OSI和TCP/IP模型的区别，每一层有哪些协议？
TCP和UDP的三次握手和四次挥手？如果只有二次握手会发生什么？只有三次挥手呢？
https是如何实现安全可靠的加密传输的？
你知道哪些状态码？返回202，300，304，500，502，504代表什么？

数据结构：

数组和Python中列表的区别？
Python中列表和元组、字符串、集合、字典的区别？
Python浅拷贝和深拷贝的区别？
Python 迭代器+生成器+装饰器？
Python中 **args和 **kwargs的区别？
满二叉树和完全二叉树的区别？
数组和链表的区别？
Python是如何实现哈希表/散列表/映射的？

测试开发：

你自己对测试的理解/为什么要做测试？
如何对一个Web页面进行测试？
测试用例：测试用户账号密码登录、微信朋友间发送图片、电商平台优惠券
用过哪些抓包测试工具？你对自己写的代码是如何进行测试的？
软件测试流程？
黑盒、白盒测试有哪些方法？区别是什么？

操作系统和其他问题：

面向对象的特征有哪些？
进程和线程的区别有哪些？
多进程和多线程的优点和缺点？
你使用过的Python第三方库有哪些？用在什么场景下？
事务的特性有哪些？
死锁是如何产生的，怎样解决？
Python是如何进行内存管理的？
GIL/如何避免受到GIL的影响？
毕业设计
Git/Svn指令
有哪些方式可以实现多线程？
用过哪些框架？在哪些情况下用到过？
dos攻击是如何实现的？
你对线程池了解多少？

算法题：

1.输出一个字符串中不重复最长连续子串的长度（比如：输入参数为字符串s = ‘abca’，输出为整型数字3）

#滑动窗口+哈希表
class Solution:
    def maxLenSub(self, astring: str) -> int:
        Dict, left, max_len = {}, 0, 0
        for i, s in enumerate(astring):
            if s in Dict:
                left = max(left, Dict[s] + 1)
            Dict[s] = i
            max_len = max(max_len, i - left + 1)
        return max_len
1
2
3
4
5
6
7
8
9
10

2.合并两个有序数组（比如：arr1 = [1,2,3]，arr2 = [7,8,9]，合并后返回为[1,2,3,7,8,9]）

#双指针
class Solution:
    def mergeSortedArr2(self, arr1: List[int], arr2: List[int]) -> List[int]:
        temp_list, i, j = [], 0, 0
        while arr1 and arr2:
            if arr1[i] < arr2[j]:
                temp_list.append(arr1.pop(i))
            else:
                temp_list.append(arr2.pop(j))
        return temp_list + arr1 + arr2
1
2
3
4
5
6
7
8
9
10

3.合并两个有序链表（意思同上）

class ListNode:
	def __init__(self,val=0, next=None):
		self.val = val
		self.next = next

class Solution:
    def mergeSortedL2(self, L1: ListNode, L2: ListNode) -> ListNode:
        if L1 is None:
            reurn L2
        elif L2 is None:
            return L1
        elif L1.val < L2.val:
            L1.next = self.mergeSortedL2(L1.next, L2)
            return L1
        else:
            L2.next = self.mergeSortedL2(L1, L2.next)
            return L2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.一个数组中最大连续子数组之和（比如：arr = [3,4,-2,-8,0,2]，则输出为7）

class Solution:
    def maxSumSub(self, arr: List[int]) -> int:
        max_sum = arr[0]
        pre_sum = 0
        for i in arr:
            if pre_sum < 0:
                pre_sum = i
            else:
                pre_sum += i
            if pre_sum > max_sum:
                max_sum = pre_sum
        return max_sum
1
2
3
4
5
6
7
8
9
10
11
12

5.整数反转（比如：输入参数为num = 123，输出参数为num = 321，120变为21，-123变为-321，注意越界情况）

def reverseInt(num):
	# 整数反转
	INT_MIN, INT_MAX = -2**31, 2**31 - 1
	total, negative_num = 0, False
	if num < 0:
		num = abs(num)
		negative_num = True
	while num != 0:
		if total < INT_MIN // 10 + 1 or total > INT_MAX // 10:
			return 0
		mod = num % 10
		num = num // 10
		total = total*10 + mod
	if negative_num is True:
		total = int('-' + str(total))
	return total
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.快排和冒泡

class Solution:
    def quickSort(self, arr: List[int]) -> List[int]:
        if len(arr) < 2:
            return arr
        else:
            pivot = arr[0]
            less = [i for i in arr[1:] if i <= pivot]
            greater = [i for i in arr[1:] if i > pivot]
            return self.quickSort(less) + [pivot] + self.quickSort(greater)

    def maopaoSort(self, arr: List[int]) -> List[int]:
        # while+for循环
        times = len(arr) - 1
        while times > 0:
            for i in range(times):
                if arr[i] > arr[i+1]:
                    arr[i], arr[i+1] = arr[i+1], arr[i]
            times -= 1
        return arr

        # 两个for循环
        # for i in range(1, len(arr)):
        #   for j in range(len(arr) - i):
        #       if arr[j] > arr[j+1]:
        #           arr[j], arr[j+1] = arr[j+1], arr[j]
        # return arr
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

7.完全二叉树的节点个数

class Solution:
    def countNodes(self, root):
        return 0 is root is None else self.countNodes(root.left) + self.countNodes(root.right) + 1
1
2
3

8.螺旋矩阵

class Solution(object):
    """
    螺旋矩阵
    """
    def spiralOrder(self, matrix):
        """
        :params matrix: 二维数组
        """
        if matrix is None or len(matrix) == 0:
            return matrix
        else:
            m, n = len(matrix), len(matrix[0])
            return self.get_spiralOrder(matrix, 0, m - 1, 0, n - 1)

    def get_spiralOrder(self, matrix, r_start, r_end, c_start, c_end):
        if r_start > r_end or c_start > c_end:
            return []
        elif r_start == r_end:
            return matrix[r_start][c_start:c_end + 1]
        elif c_start == c_end:
            return [matrix[i][c_end] for i in range(r_start, r_end + 1)]
        else:
            curr = matrix[r_start][c_start:c_end + 1] + [matrix[i][c_end] for i in range(r_start + 1, r_end)] + \
            matrix[r_end][c_start:c_end + 1][::-1] + [matrix[i][c_start] for i in reversed(range(r_start + 1, r_end))]
            res = curr + self.get_spiralOrder(matrix, r_start + 1, r_end - 1, c_start + 1, c_end - 1)
            return res
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

9.反转链表

class Solution:
    def reverse(self, head: ListNode):
        pre = None
        curr = head
        while curr is not None:
            curr.next = pre
            pre = curr
            curr = curr.next
        return pre
1
2
3
4
5
6
7
8
9

10.N叉树的前序遍历和后序遍历

class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children

    # N叉树的前序遍历
    def preOrder(self, root: Node):
        ans = []
        def dfs(node: Node):
            if node is None:
                return node
            ans.append(node.val)
            for ch in node.children:
                dfs(ch)
        dfs(root)
        return ans

    # N叉树的后序遍历
    def postOrder(self, root: Node):
        ans = []
        def dfs(node: Node):
            if node is Node:
                return node
            for ch in node.children:
                dfs(ch)
            ans.append(node.val)
        dfs(root)
        return ans
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

11.最长有效括号长度

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        if not s:
            return 0
        res = []
        stack = []
        for i in range(len(s)):
            if stack and s[i] == ")":
                res.append(stack.pop())
                res.append(i)
            if s[i] == "(":
                stack.append(i)
        res.sort()
        #print(res)
        i = 0
        ans = 0
        n = len(res)
        while i < n:
            j = i
            while j < n - 1 and res[j + 1] == res[j] + 1:
                j += 1
            ans = max(ans, j - i + 1)
            i = j + 1
        return ans
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

12.输出字符串中每个字符出现次数

class Solution:
    def stringCount1(self, astring: str) -> dict:
        return {i:astring.count(i) for i in astring}

    def stringCount2(self, astring: str) -> dict:
        Dict = {}
        for s in astring:
            Dict[s] = Dict[s] + 1 if s in Dict else 1
        return Dict
1
2
3
4
5
6
7
8
9

13.数组中的最大和最小值交换位置，其他元素的位置不变（比如arr = [1,89,56,45,23]，输出为[89,1,56,45,23]）

class Solution:
    def swapOfArr(self, arr):
        def Biggest(arr):
            biggest = arr[0]
            biggest_index = 0
            for i in range(len(arr)):
                if arr[i] > biggest:
                    biggest = arr[i]
                    biggest_index = i
            return biggest_index

        def Smallest(arr):
            smallest = arr[0]
            smallest_index = 0
            for i in range(len(arr)):
                if arr[i] < smallest:
                    smallest = arr[i]
                    smallest_index = i
            return smallest_index
        biggest_index = Biggest(arr)
        smallest_index = Smallest(arr)
        arr[biggest_index], arr[smallest_index] = arr[smallest_index], arr[biggest_index]
        return arr
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

14.两个栈实现一个队列

class Queue:
    # 两个栈实现一个队列
    def __init__(self):
        self.A, self.B = [], []

    def appendTail(self, value: int) -> None:
        self.A.append(value)

    def deleteHead(self) -> int:
        if self.B: return self.B.pop()
        if not self.A: return -1
        while self.A:
            self.B.append(self.A.pop())
        return self.B.pop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

15.最长递增子数组长度（比如：arr = [2,-1,5,8,-3,9]，输出为4）

class Solution:
    # 最长递增子数组长度
    def lengthOfLIS(self, nums: list) -> int:
        if not nums:
            return 0
        dp = []
        for i in range(len(nums)):
            dp.append(1)
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
        return max(dp)
1
2
3
4
5
6
7
8
9
10
11
12

16.字符串的翻转（比如输入参数为字符串s = 'abcd', k = 2，则输出参数为字符串'bacd'）

class Solution:
	def reverseStr1(self, s: str, k: int) -> str:
		str_arr = [i for i in s]
		for i in range(0, len(str_arr), 2*k):
			str_arr[i:i+k] = str_arr[i:i+k][::-1]
		return ''.join(str_arr)
		
	def reverseStr2(self, s: str, k: int) -> str:
		i, newStr = 0, ''
		while i < len(s):
			newStr += s[i:i+k][::-1] + s[i+k:i+2*k]
			i += 2*k
		return newStr
1
2
3
4
5
6
7
8
9
10
11
12
13

二、Java(后端/服务端/算法/测试开发)

主观题：

同上

数据库：

Java在数据库中如何保证原子性？
其他同上

计算机网络：

同上

数据结构：

StringBuilder和StringBuffer有哪些区别？
HashMap的底层实现原理？
Java中i++和++i的区别？
Java中wait和sleep的区别是什么？
JVM原理实现？
B+数索引是如何实现的？
integer和int的区别？
ArrayList继承或者实现了什么？
Java中的垃圾回收机制？

操作系统和其他问题：

Java中如何开启多个线程
Java是如何进行上锁的？有哪些区别？
spring有哪些实现模块？
Java是如何实现反射的以及原理？
阻塞IO和非阻塞IO？
Ajax的实现原理是什么？
Java和JS编译原理区别有哪些？
你知道哪些设计模式？
中断和陷入是什么？
spring中Ioc和Aop概念？
简单工厂和抽象工厂有什么区别？
单例模式的手写？
乐观锁和悲观索？
Java中重载和重写区别？
虚函数实现原理？
指针和引用的区别有哪些？

算法题：

同上

三、原文链接

阅读原文

四、作者Info

作者：小鸿的摸鱼日常，Goal：让编程更有趣！

原创微信公众号：『小鸿星空科技』，专注于校招(内推/笔经/面经)、算法、爬虫，网站，游戏开发，数据分析、自然语言处理，AI等，期待你的关注，让我们一起成长、一起Coding！

版权说明：本文禁止抄袭、转载，侵权必究！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/282446

2022春招各大厂高频面试题汇总_力扣2022春招高频面试题

目录

一、Python(后端/服务端/算法/测试开发)

二、Java(后端/服务端/算法/测试开发)

三、原文链接

四、作者Info