快手测开面试
一、算法题
1.最长回文子串
给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：
输入：s = "babad" 输出："bab" 解释："aba" 同样是符合题意的答案。
class Solution:
def longestPalindrome(self, s: str) -> str:
def isHuiWenStr(subStr:str):#判断当前子串是不是回文字符
start = 0
end = len(subStr) - 1
while(start < end):
if(subStr[start] != subStr[end]):
return False
start = start + 1
end = end - 1
return True
if(len(s) < 2):
return s
maxLen = 1#记录最大回文字符长度
begin = 0#记录最大回文字符的起点
for i in range(len(s)-1):
for j in range(i + 1, len(s)):
if((j - i + 1) > maxLen and isHuiWenStr(s[i:j+1])):
maxLen = j - i + 1
begin = i
return s[begin:begin + maxLen]2. 最长公共子序列
class Solution(object):
def longestCommonSubsequence(self, text1, text2):
M, N = len(text1), len(text2)
dp = [[0] * (N + 1) for _ in range(M + 1)]
for i in range(1, M + 1):
for j in range(1, N + 1):
if text1[i - 1] == text2[j - 1]:
dp[i][j] = dp[i - 1][j - 1] + 1
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
return dp[M][N]
3. 最长递增子序列
# Dynamic programming.
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
if not nums: return 0
dp = [1] * len(nums)
for i in range(len(nums)):
for j in range(i):
if nums[j] < nums[i]: # 如果要求非严格递增，将此行 '<' 改为 '<=' 即可。
dp[i] = max(dp[i], dp[j] + 1)
return max(dp)
最长递增子序列II:
class Solution:
def lengthOfLIS(self, nums: List[int], k: int) -> int:
n=len(nums)
e=max(nums)
lst=[0]*(4*e)
def query(l,r,s,t,p):
if l<=s and r>=t:
return lst[p]
mid=(s+t)//2
cmax=0
if l<=mid:
cmax=max(cmax,query(l,r,s,mid,2*p))
if r>mid:
cmax=max(cmax,query(l,r,mid+1,t,2*p+1))
return cmax
def update(key,val,l,r,p):
if l==r and l==key:
lst[p]=max(lst[p],val)
return
if l<=key and r>=key:
lst[p]=max(lst[p],val)
mid=(l+r)//2
if key<=mid:
update(key,val,l,mid,2*p)
else:
update(key,val,mid+1,r,2*p+1)
ans=1
update(nums[0],1,0,e,1)
for i in range(1,n):
cur=nums[i]
t=query(cur-k,cur-1,0,e,1)
ans=max(ans,t+1)
update(cur,t+1,0,e,1)
return ans
4. 前K个高频元素
class Solution:
def topKFrequent(self, nums: List[int], k: int) -> List[int]:
n = len(nums)
dic = {}
for i in range(n):
if nums[i] not in dic:
dic[nums[i]] = 1
else:
dic[nums[i]] += 1
res = []
while k > 0:
tmp = 0
for num in dic:
if dic[num] > tmp:
tmp = dic[num]
cur = num
dic[cur] = -1
res.append(cur)
k -= 1
return res
5. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
算法思路：
采用归并排序的思想，将每次num1和num2较大的值归并入num1末端（递增排序），如果num1里的元素先归并完了，就直接将num2剩余元素直接放入num1（num1和num2都递增）
class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
Do not return anything, modify nums1 in-place instead.
"""
while(m > 0 and n >0):
if(nums1[m-1] > nums2[n-1]):
nums1[m+n-1] = nums1[m-1]
m -= 1
else:
nums1[m+n-1] = nums2[n-1]
n -= 1
if(n > 0):#num1先归并完了,将num2剩余元素直接放入num1
nums1[:n] = nums2[:n]
6. 买卖股票最佳时机III
class Solution:
def maxProfit(self, prices: List[int]) -> int:
n = len(prices)
buy1 = buy2 = -prices[0]
sell1 = sell2 = 0
for i in range(1, n):
buy1 = max(buy1, -prices[i])
sell1 = max(sell1, buy1 + prices[i])
buy2 = max(buy2, sell1 - prices[i])
sell2 = max(sell2, buy2 + prices[i])
return sell2
7. 链表删除倒数第n个节点
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeNthFromEnd(self, head, n):
left = right = head
count = 0
while count < n:
right = right.next
count += 1
if not right:
return head.next
while right.next:
left = left.next
right = right.next
left.next = left.next.next
return head
8. 搜索二维矩阵，二分查找
class Solution:
def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
for row in matrix:
for element in row:
if element == target:
return True
return False
class Solution:
def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
i, j = len(matrix) - 1, 0
while i >= 0 and j < len(matrix[0]):
if matrix[i][j] > target: i -= 1
elif matrix[i][j] < target: j += 1
else: return True
return False
9. 括号匹配
class Solution:
def isValid(self, s: str) -> bool:
dic = {')':'(',']':'[','}':'{'}
stack = []
for i in s:
if stack and i in dic:
if stack[-1] == dic[i]: stack.pop()
else: return False
else: stack.append(i)
return not stack
class Solution:
def checkValidString(self, s: str) -> bool:
def help(a):
cnt = 0
for c in s if a == 1 else reversed(s):
if c == '(': cnt += a
if c == ')': cnt += -a
if c == '*': cnt += 1
if cnt < 0:
return False
return True
return help(1) and help(-1)
9. 数组中出现次数超过数组长度一半的数字
class Solution:
def majorityElement(self, nums: List[int]) -> int:
votes = 0
for num in nums:
if votes == 0: x = num
votes += 1 if num == x else -1
return x
10. 手撕单例模式
（1）饿汉式单例：（立即加载）
// 饿汉式单例
public class Singleton1 {
// 指向自己实例的私有静态引用，主动创建
private static Singleton1 singleton1 = new Singleton1();
// 私有的构造方法
private Singleton1(){}
// 以自己实例为返回值的静态的公有方法，静态工厂方法
public static Singleton1 getSingleton1(){
return singleton1;
}
}（2）懒汉式单例：（延迟加载）
// 懒汉式单例
public class Singleton2 {
// 指向自己实例的私有静态引用
private static Singleton2 singleton2;
// 私有的构造方法
private Singleton2(){}
// 以自己实例为返回值的静态的公有方法，静态工厂方法
public static Singleton2 getSingleton2(){
// 被动创建，在真正需要使用时才去创建
if (singleton2 == null) {
singleton2 = new Singleton2();
}
return singleton2;
}
}11. 层序二叉树
class Solution:
def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
if not root: return []
res, queue = [], collections.deque()
queue.append(root)
while queue:
tmp = []
for _ in range(len(queue)):
node = queue.popleft()
tmp.append(node.val)
if node.left: queue.append(node.left)
if node.right: queue.append(node.right)
res.append(tmp)
return res
12. 一副扑克牌54张，判断（包含大小王）随机取5张牌，判断是不是顺子
class Solution:
def isStraight(self, nums: List[int]) -> bool:
repeat = set()
ma, mi = 0, 14
for num in nums:
if num == 0: continue # 跳过大小王
ma = max(ma, num) # 最大牌
mi = min(mi, num) # 最小牌
if num in repeat: return False # 若有重复，提前返回 false
repeat.add(num) # 添加牌至 Set
return ma - mi < 5 # 最大牌 - 最小牌 < 5 则可构成顺子
13. 数组中第k个大的数的索引，并追问如何设计测试用例，你写的代码有什么问题没有，问时间复杂度
def find_kth_largest_index(nums, k):
sorted_nums = sorted(range(len(nums)), key=lambda x: nums[x], reverse=True)
return sorted_nums[k-1]关于测试用例的设计，你可以考虑以下几种情况：
- 正常情况下的输入测试，包括不同长度的数组和不同范围的整数。
- 边界情况，例如数组只有一个元素或者只有两个元素。
- 特殊情况，例如数组中存在相同的元素。
关于代码的问题，上述代码的问题在于使用了sorted函数对数组进行排序，它的时间复杂度为O(nlogn)。如果数组很大，可能会影响性能。可以使用快速选择算法来优化时间复杂度。
快速选择算法的时间复杂度为O(n)，它的实现方式类似于快速排序。你可以通过将数组分成两部分来确定第k个大的数所在的位置，从而减少排序的时间复杂度。
14. sql 现在有一张学生表abc ，有三个字段id name score，请查询出成绩排名为第二的学生姓名
SELECT name FROM abc ORDER BY score DESC LIMIT 1 OFFSET 1;二、八股
1.在运行项目之前，Springboot底层原理，有哪些类，以什么顺序执行
（1）SpringApplication: 是启动Spring Boot应用的起始点。当运行 SpringApplication.run 方法时，它会执行以下操作：
推断应用类型（是否是Web应用）。
设置默认属性。
加载所有的 Spring 配置属性。
配置日志。
创建并返回一个 Spring 的 ApplicationContext 实例。
（2）SpringFactoriesLoader: 这个类用于从 classpath 下的 META-INF/spring.factories 文件中加载配置。这是 Spring Boot 扩展自动配置、提供其他 Spring Boot 初始器的主要机制。
（3）@SpringBootApplication: 这个注解实际上是一个组合注解，它组合了以下三个注解：
@SpringBootConfiguration: 表明该类是配置类。
@EnableAutoConfiguration: 启用 Spring Boot 的自动配置。
@ComponentScan: 启用组件扫描。
（4）AutoConfigurationImportSelector: 这个类读取 META-INF/spring.factories 中配置的所有自动配置类，并基于条件评估决定哪些自动配置需要被激活。
（5）ApplicationContext：Spring的上下文对象，所有的Bean都是在这里被管理。
Spring Boot在启动过程中创建了特定类型的ApplicationContext（基于应用类型，例如Web应用会创建AnnotationConfigServletWebServerApplicationContext）。
（6）内嵌 Servlet 容器：如 Tomcat、Jetty 或 Undertow。
Spring Boot 的一个特点是它可以打包为一个独立的JAR，这个JAR包含了一个内嵌的Servlet容器。所以，当应用启动时，这个内嵌的容器也会被启动。
执行顺序简述：
主类（通常带有 public static void main 方法）调用 SpringApplication.run。
创建 SpringApplication 对象。
应用 SpringFactoriesLoader 加载 META-INF/spring.factories 中的配置。
初始化 ApplicationContext。
调用 @EnableAutoConfiguration 加载自动配置。
初始化内嵌的 Servlet 容器。
启动容器并开始监听请求。2. 白盒黑盒测试说一下，分别是怎样的
(1)白盒测试（White Box Testing）
-
定义：白盒测试，又称为结构测试、逻辑驱动测试或代码级测试，它是基于程序代码的结构或算法来设计测试用例的。
-
测试内容：
- 检查代码的分支、循环等逻辑结构是否都被执行。
- 路径测试，确保所有的路径都被测试。
- 函数测试，确保函数、方法或类按照预期工作。
-
工具：可能会使用代码覆盖工具来检查代码的哪些部分被测试，哪些部分没有。
-
优点：
- 可以发现代码中的隐藏错误。
- 提供了代码覆盖率的明确指标。
-
缺点：
- 可能漏掉对一些系统功能的测试。
- 通常比较耗时。
(2) 黑盒测试（Black Box Testing）
-
定义：黑盒测试，又称功能测试，主要关注程序功能，而不考虑其内部结构或工作原理。测试是基于输入和预期输出。
-
测试内容：
- 用户界面和用户体验。
- 数据库功能。
- 对输入的处理和对应的输出。
- 系统功能。
-
工具：可能会使用自动测试工具，如 Selenium 或 QTP，来模拟用户操作并检查结果。
-
优点：
- 更接近真实用户的使用情境。
- 可以发现和用户交互相关的问题。
- 测试人员不需要知道代码或内部结构。
-
缺点：
- 不能发现代码的隐藏问题。
- 有可能遗漏某些不明显的功能性问题。
3. http和https区别，http请求什么结构，请求头的作用是什么
(1)HTTP与HTTPS的区别
-
安全性：
- HTTP：超文本传输协议，信息是明文传输，存在安全风险。
- HTTPS：即HTTP加入SSL层，超文本传输安全协议。信息是经过加密的，更加安全。
-
端口：
- HTTP：使用端口80。
- HTTPS：使用端口443。
-
性能：
- HTTP：因为没有加密，所以HTTP的速度比较快。
- HTTPS：需要进行加密处理，因此相对较慢（但随着现代技术的发展，这种差异已经被最小化）。
-
证书：
- HTTP：不需要证书。
- HTTPS：需要SSL证书。如果网站使用的是自签名的SSL证书，浏览器会提示访问者。
(2) HTTP请求结构
一个HTTP请求主要包含以下部分：
- 请求行：包括请求方法（如GET, POST, PUT, DELETE等）、请求URI以及HTTP版本。
- 请求头（Headers）：描述请求的元数据或其他信息，如User-Agent（浏览器类型）、Accept（可接受的回复类型）、Host（请求的服务器）等。
- 空行：请求头和请求体之间的分隔符。
- 请求体（Body）：POST或PUT请求中传送的数据。
(3) 请求头的作用
请求头在HTTP请求中扮演了重要的角色，它为服务器提供了关于客户端请求的一些信息。以下是请求头的一些常见用途：
- 内容类型：通过
Content-Type头部，客户端可以告诉服务器发送的数据是什么格式，如application/json或text/html。 - 内容长度：通过
Content-Length头部，指示请求或响应体的大小。 - 认证：例如，
Authorization头部用于包含凭据，通常用于API认证。 - 缓存控制：
Cache-Control和其他相关的头部可以控制如何缓存响应内容。 - 用户代理：
User-Agent头部描述了发出请求的客户端类型，如浏览器或其他客户端应用。 - 接受的内容类型：通过
Accept头部，客户端可以告诉服务器它希望收到哪种类型的响应。 - Cookies：
Cookie头部可以包含服务器设置的任何cookie，它们在每个请求中发送回服务器。 - 跨域请求：
Origin头部表示请求来自哪个源，与CORS（跨来源资源共享）策略相关。
4.TCP和UDP的区别，TCP三次握手，为什么不是两次握手
(1) TCP与UDP的区别
-
连接的性质：
- TCP：是一个面向连接的协议。这意味着在数据传输前，两个通信端需要建立一个连接。
- UDP：是一个无连接的协议。数据在发送前不需要建立连接。
-
可靠性：
- TCP：提供了数据的可靠传输。它有确认、超时重传、错误检测、流量控制等机制来确保数据正确、完整地从发送端传输到接收端。
- UDP：不保证数据的可靠传输。数据包在网络中可能会丢失、乱序或重复。
-
数据的边界性：
- TCP：是字节流的形式，没有明确的边界。
- UDP：是数据报文的形式，每个数据报文都有明确的边界。
-
速度：
- TCP：由于其可靠性机制，相对较慢。
- UDP：因为它缺少大部分的错误检测和校正机制，所以传输速度相对较快。
-
用途：
- TCP：被广泛应用在需要数据可靠性的场合，如网页浏览、文件传输、电子邮件等。
- UDP：通常用于广播和多播传输、视频会议、流媒体等，这些应用对数据的实时性有较高的要求。
（2）TCP三次握手为什么是三次握手而不是两次？
三次握手是TCP协议建立连接的过程，具体步骤如下：
- SYN：客户端发送一个SYN包（同步序列编号）到服务器，请求建立连接。
- SYN-ACK：服务器收到SYN包后，返回一个SYN-ACK包（同步应答）来确认客户端的SYN。
- ACK：客户端再发送一个ACK包（确认）给服务器，确认服务器的SYN-ACK。
三次握手原因：
-
防止已失效的连接请求报文段突然传到了服务端：考虑一个场景，客户端发送了第一个连接请求，但是由于网络原因这个请求被延迟了，于是TCP又发送了一个连接请求。当网络好转时，两个连接请求几乎同时到达服务端，如果此时是两次握手，服务端就会建立两个连接，但客户端只建立了一个连接，这就造成了服务端资源的浪费。
-
更为可靠地确认双方的接收与发送能力：三次握手可以确保双方都有接收和发送消息的能力。两次握手无法保证这一点。
-
设定序列号：三次握手还可以使得双方都能为TCP连接初始的序列号达成一致
5.URL输入到网页展示
-
地址解析：
- 浏览器检查URL是否在本地缓存中有对应的IP地址。
- 如果没有，浏览器会向系统的默认DNS服务器请求解析该URL对应的IP地址。
- DNS服务器响应请求，返回对应的IP地址。
-
建立TCP连接：
- 浏览器与远程服务器通过三次握手建立TCP连接。
-
发送HTTP请求：
- 浏览器发送HTTP请求到服务器。
-
服务器处理请求并返回HTTP响应：
- 服务器处理接收到的请求。
- 服务器返回一个HTTP响应给浏览器。
-
浏览器解析并渲染页面：
- 浏览器首先解析HTML来构建DOM树。
- 浏览器解析CSS样式信息，与DOM树结合，形成渲染树。
- 浏览器布局渲染树（进行布局计算）。
- 浏览器绘制渲染树，展示页面内容。
-
加载嵌套的资源：
- HTML页面中可能包含嵌套的资源，如图片、CSS、JavaScript等。浏览器会对这些资源进行上述相同的过程：解析地址、建立连接、请求资源、获取响应、处理和渲染。
-
执行JavaScript：
- 浏览器解析和执行JavaScript代码。这可能会修改页面内容。
-
关闭连接：
- 如果HTTP/1.1的“Keep-Alive”参数没有被使用，浏览器会关闭TCP连接。若使用了HTTP/2，则连接在多个请求中可能被重用。
6. where和having区别
- “Where” 是一个约束声明，是在查询结果集返回之前约束来自数据库的数据，且Where中不能使用聚合函数。
- “Having”是一个过滤声明，是在查询结果集返回以后对查询结果进行的过滤操作，在Having中可以使用聚合函数。
7. MySQL聚合函数的关键字
AVG、COUNT、MAX、MIN、SUM
8. 如何解决读写冲突
-
锁定：
- 互斥锁（Mutex）：确保任何时候只有一个线程可以访问资源。
- 读写锁（ReadWriteLock）：允许多个线程同时读，但只允许一个线程写入。这比全互斥锁更加灵活，因为它只在写入时阻止其他线程/进程访问。
- 乐观锁：基于数据版本控制，读取数据时记录其版本，写入时检查版本是否改变，若未改变则写入，否则重试。
-
原子操作：
- 使用硬件或软件提供的原子操作来确保读写的一致性，例如
compare-and-swap。
- 使用硬件或软件提供的原子操作来确保读写的一致性，例如
-
隔离级别：
- 在数据库中，事务的隔离级别可以定义多个事务之间的可见性和冲突解决策略，例如“读已提交”或“可重复读”。
-
序列化访问：
- 确保一次只有一个请求可以访问数据，例如使用消息队列。
-
分布式锁：
- 在分布式系统中，可以使用分布式锁来确保多个节点上的进程不会同时写入。。
-
冲突检测与回滚：
- 当检测到冲突时，可以选择回滚操作，并在合适的时机重试。
9. 多表冲突怎么解决
-
事务：
- 使用事务可以确保一组操作作为一个单元执行，即它们要么全部成功，要么全部失败。这有助于确保数据的完整性和一致性。
-
锁定策略：
- 表级锁：当操作需要访问整个表时，可以使用表级锁。
- 行级锁：只锁定被操作的特定行，从而允许多个事务可以并发访问同一个表的不同行。
- 页级锁：介于表级锁和行级锁之间，锁定数据页。
-
死锁检测与预防：
- 数据库系统通常都有死锁检测机制。当检测到死锁时，数据库会选择一个事务进行回滚，从而解除死锁。
- 为了预防死锁，可以尝试让所有的事务都按相同的顺序访问表。
-
优化查询：
- 通过优化查询，减少所需的锁的数量和持续时间，从而降低冲突的可能性。
-
乐观并发控制：
- 通过版本号或时间戳等机制，在提交更改时检查数据是否已被其他事务修改。如果数据已更改，事务会失败并需要重试。
-
减少事务持续时间：
- 通过减少事务的持续时间，可以减少冲突的机会。例如，尽可能快地提交事务或将长事务分解为多个短事务。
-
隔离级别：
- 调整数据库的事务隔离级别可以影响锁的行为。例如，
READ COMMITTED和SERIALIZABLE在锁定策略上有很大的不同。
- 调整数据库的事务隔离级别可以影响锁的行为。例如，
-
分区：
- 将数据分区到不同的物理存储区域可以减少锁定的竞争。
10. JVM内存模型、垃圾回收机制、进入老年代的阈值、JVM可调整的参数
(1)JVM内存模型
JVM内存大致可以划分为以下几个部分：
- 方法区（Method Area）：存放类信息、静态变量、常量、即时编译器编译后的代码等。
- 堆（Heap）：是Java中最大的一块内存区域，主要用于存放对象实例。堆进一步可以细分为：
- 新生代（Young Generation）：新创建的对象首先进入新生代，它又可以分为：
- Eden区
- 两个Survivor区 (S0和S1)
- 老年代（Old Generation/Tenured）：长时间存活的对象会被移至老年代。
- 新生代（Young Generation）：新创建的对象首先进入新生代，它又可以分为：
- Java栈（Java Stack）：每个线程创建时都会创建一个Java栈，用于存放局部变量、操作栈、动态链接、方法出入口等。
- 本地方法栈（Native Method Stack）：为JVM使用到的Native方法服务。
- 程序计数器（Program Counter Register）：当前线程所执行的字节码的行号指示器。
(2) 垃圾回收机制
主要回收对象存放的主内存区域：堆和方法区。主要算法：
- 标记-清除（Mark-Sweep）
- 复制算法（Copying）：主要在新生代中使用，比如Eden区与两个Survivor区之间。
- 标记-整理（Mark-Compact）
- 分代收集算法（Generational Collection）
(3) 进入老年代的阈值
对象从新生代进入老年代通常是基于它们的年龄。如果对象在新生代中经过了特定次数的GC后仍然存活，它就会被移至老年代。这个“特定次数”就是阈值，通常可通过参数-XX:MaxTenuringThreshold来设置。
(4) JVM可调整的参数
JVM有许多可调整的参数。以下是一些常用的参数：
- 堆的设置：
-Xms：设置初始堆大小。-Xmx：设置最大堆大小。
- 新生代与老年代的比例：
-XX:NewRatio：设置新生代与老年代的大小比例。
- 调整Eden与Survivor区的大小：
-XX:SurvivorRatio
- 设置年龄阈值：
-XX:MaxTenuringThreshold：设置对象进入老年代的年龄阈值。
- 选择垃圾回收器：
-XX:+UseSerialGC：选择串行回收器。-XX:+UseParallelGC：选择并行回收器。-XX:+UseConcMarkSweepGC：选择CMS回收器。-XX:+UseG1GC：选择G1回收器。
11. 垃圾收集器有哪些，gc方式
Java的垃圾收集器有多种，每种都有其特定的应用场景和优势。以下是常见的垃圾收集器及其工作方式：
(1) Serial收集器（Serial GC）
- 适用场景：单线程环境，如简单的命令行程序。
- 工作方式：使用单个线程进行垃圾收集，因此在垃圾收集时，用户线程会被暂停。
- 启用方式：
-XX:+UseSerialGC
(2) Parallel（或 Throughput）收集器
- 适用场景：多线程应用，追求高吞吐量。
- 工作方式：使用多个线程并行地执行垃圾收集，但在垃圾收集期间会停止所有用户线程。
- 启用方式：
-XX:+UseParallelGC
(3) CMS（Concurrent Mark Sweep）收集器
- 适用场景：低延迟应用，如Web服务器或交互式应用。
- 工作方式：
- 初始标记：暂停所有线程，标记GC Roots能直接关联的对象。
- 并发标记：与用户线程并发运行，标记从GC Roots可达的对象。
- 重新标记：暂停所有线程，修正并发标记阶段因用户程序继续运行而导致的标记变动。
- 并发清除：与用户线程并发运行，清除不再使用的对象。
- 启用方式：
-XX:+UseConcMarkSweepGC
计算机网络，osi模型，模型各层功能介绍，排序算法，各个排序算法怎么实现，复杂度怎么样
Linux命令：一个文件追加到另一个文件，文件重命名，文件查找字符串
java反射、多线程、垃圾回收
post和get的区别
说一下java的数据结构
Java中的基本数据类型有哪些？
String、StringBuffer的区别
hashmap是线程安全的吗
什么情况下需要用到多线程
java线程的生命周期
如何强制结束一个线程
java创建线程有几种方式
使用乐观锁会不会出现脏读问题？
Mysql里的锁都有哪些？
MySQL主键是唯一索引吗
什么适合做索引，mysql底层数据结构，b+树，什么存储引擎底层用的b树
三、场景题
1. 超多数，一亿个量级的那种，找到最大的10个
- 首先，遍历一次数组，将前10个数作为初始的最大数集合。
- 遍历数组的剩余部分，对于每个数，如果它比当前最大数集合中的最小数大，则替换最小数，并重新调整最大数集合的顺序。
- 最后，最大数集合中的10个数即为所需的最大的10个数。
2. 一张大表划分优化，分成为多个小表，怎么测试小表
（1）数据完整性测试:
确保原始大表中的所有数据都出现在某个小表中。确保数据没有重复，也就是说，
一个数据行不应该出现在多个小表中。确保所有的约束和关系（如外键）都仍然成立。
（2）查询测试:
如果你对原始大表有预定义的查询，确保它们在小表上也能正确运行。
为了验证性能提升，对相同的查询进行基准测试，比较分片前后的执行时间。
（3）写入测试:
确保新数据可以正确地写入适当的小表。测试批量写入的性能，确保它符合或超过你的性能要求。
（4）故障恢复测试:
尝试模拟小表的故障并恢复，确保没有数据丢失。确保备份和恢复策略仍然有效。
（5）并发性测试:
用多个并发用户或进程测试小表，确保系统仍然稳定和响应。检查是否有任何的锁定或并发性问题。
(6) 应用集成测试:
如果你有依赖原始大表的应用程序，确保它们能够正确地与小表集成，并且所有的功能都正常工作。
（7）负载测试:
根据预期的工作负荷进行负载测试，确保系统的性能满足要求。监控系统资源使用情况，如CPU、内存和磁盘。
(8) 迁移测试:
如果你计划在生产环境中迁移到这些小表，考虑执行迁移测试，模拟真实的迁移过程。
(9) 验证工具:
使用数据库验证工具，检查数据的一致性和完整性。
(10) 安全性测试:
确保所有的小表都与原始大表具有相同的安全性标准和策略。
执行安全性测试以确保数据在分片后仍然安全。3. 知名电商京东淘宝，怎么样测试用户的购物车
(1)基本功能测试:
添加商品到购物车：单个商品、多个商品、不同种类的商品。
从购物车中删除商品。
更改购物车中商品的数量。
选择/取消选择购物车中的商品。
(2) UI/UX测试:
购物车界面在不同设备和浏览器中的显示。
响应性测试，确保在移动设备上也有良好的体验。
购物车的加载速度。
(3) 数据一致性测试:
购物车显示的价格与商品页面显示的价格是否一致。
库存检查：当库存不足时，购物车应该有相应的提示。
(4) 购物车更新测试:
当商品价格或属性（如颜色、尺寸等）发生变化时，购物车中的商品信息是否会更新。
(5) 并发性测试:
多个用户同时操作购物车时的表现，如同时添加、删除商品。
(6) 持久性测试:
退出并重新登录后，购物车的商品是否仍然存在。
在不同设备和浏览器上登录，购物车的内容是否一致。
(7) 集成测试:
购物车与其他模块（如支付、优惠券、积分系统等）的集成。
购物车到结账流程的完整性测试。
(8) 安全性和隐私测试:
确保未登录或其他用户无法访问用户的购物车。
确保所有数据传输，特别是结账时，都是加密的。
(9) 异常和边界测试:
尝试添加库存超出的商品数量到购物车。
尝试在购物车中加入已下架的商品。
当购物车为空时的界面和提示。
(10) 性能测试:
加载含有大量商品的购物车时的性能。
(11)通知和提示测试
当商品缺货或价格变化时，用户是否会收到相应的通知。
购物车中的操作（如删除商品）是否有相应的确认提示。4. 怎么测试登录页面， 请测试用例设计
(1) UI/UX测试:
检查所有元素（如文本框、标签、按钮、链接）是否正确显示。
确保错误提示清晰、友好并易于理解。
确保所有文本框、按钮、链接等都可点击且反应正常。
检查页面是否在各种屏幕尺寸和分辨率下响应正常。
(2) 功能测试:
使用有效的用户名和密码登录。
使用无效的用户名和密码登录。
使用有效的用户名和无效的密码登录。
使用无效的用户名和有效的密码登录。
使用空用户名和密码尝试登录。
确保“忘记密码”功能或链接可用。
(3) 输入验证测试:
在用户名/密码字段中输入特殊字符、空格等，检查应用的响应。
输入超长或超短的用户名和密码。
输入SQL注入、脚本注入等攻击向量，检查应用的响应。
(4)错误处理测试:
检查当提供错误的凭据时是否显示了合适的错误消息。
在多次尝试错误的登录凭据后，检查是否有锁定策略或验证码要求。
(5) 会话和安全性测试:
登录后，直接访问登录页面，确保应用将用户重定向到主页面或显示已登录状态。
登录后关闭浏览器或标签，再次打开，确保用户仍然登录。
登录后，修改URL地址到其他页面，然后再返回，确保用户仍然登录。
使用HTTP（非HTTPS）登录，确保密码不是明文传输。
检查cookies和session的安全设置，如httpOnly、secure等。
(6) 多用户类型登录测试（如果适用）:
尝试使用不同类型的用户（如管理员、普通用户、访客）登录，并确保他们被正确地重定向到他们的主页面。
(7) 浏览器兼容性测试:
在不同的浏览器和版本中测试登录页面。
(8) 性能测试:
模拟多用户同时登录，检查页面加载速度和服务器响应时间。
(9) 重置密码和验证码功能测试（如果适用）:
尝试使用“忘记密码”功能重置密码。
在被要求时正确和错误地输入验证码。
(10) 多语言和多地区测试（如果适用）:
切换不同的语言或地区，确保登录页面的内容和错误消息正确地翻译5. 微信好友发送图片写测试用例
(1) 功能性测试:
从相册选择图片并成功发送。
使用相机拍摄新照片并成功发送。
选择并发送多张图片。
图片发送进度条显示并在发送完毕后消失。
在发送图片的过程中，能够成功取消发送。
(2) 文件大小和格式测试:
尝试发送大于微信允许的最大文件大小的图片。
尝试发送不同格式的图片文件（如JPG、PNG、GIF、BMP等）。
尝试发送损坏或不完整的图片文件。
(3) UI/UX测试:
在不同屏幕尺寸的设备上检查图片的显示效果。
长按已发送的图片，确保弹出菜单（如转发、保存、删除等）正常工作。
检查点击图片后的放大、缩小、左右滑动等查看功能。
(4) 网络和性能测试:
在不同的网络环境（如4G、5G、WiFi、慢速网络）下发送图片，确保发送速度和稳定性。
在网络信号不稳定或断开的情况下尝试发送图片。
(5) 安全性和隐私测试:
确保未授权的应用或用户无法访问发送的图片。
检查图片存储和传输是否有加密。
(6) 错误处理测试:
当发送大量或超大文件时，检查是否有合适的错误消息。
当磁盘空间不足时，尝试发送图片并检查是否有相应的提示。
(7) 集成测试:
发送图片后，尝试使用其他功能，如语音、视频、红包等，确保它们不受影响。
在聊天界面外，如朋友圈、微信群等，尝试发送图片。
(8) 其他测试:
旋转设备并在横屏模式下发送图片。
在应用后台运行时发送图片。
修改设备的系统日期和时间，然后尝试发送图片。
(9) 互通性测试:
从不同版本的微信发送图片，并确保接收方可以正确显示。
(10) 多语言和地区测试（如果适用）:
在不同的语言设置下尝试发送图片，确保所有的提示、错误消息等都被正确翻译。6. 快手商城购物车点开到页面渲染出来的时间怎么精确计算
(1) 前端性能监控工具:
使用前端性能监控工具，例如Google Chrome的内置开发者工具，可以提供详细的页面加载时间报告。
如何操作：
打开Chrome开发者工具（F12或右键页面选择“检查”）。
转到“网络”或“Performance”选项卡。
清空缓存并刷新页面或模拟点击操作。
你可以看到页面的详细加载时间线，并准确知道何时页面开始加载、何时DOM完成、何时所有资源（如图片、JS、CSS等）都被下载和执行完毕。
(2) 使用第三方性能监控服务：
有许多第三方服务，如New Relic, LogRocket, FullStory等，提供页面性能监控功能。
这些工具可以为你提供页面的加载和渲染时间，同时还提供其他有关页面性能的详细信息
(3)服务器日志：
尽管大部分的页面渲染时间发生在客户端，但你还可以检查服务器日志以确定服务器响应的时间。
这有助于分析页面加载时间中哪一部分是由服务器引起的7. 4分钟+七分钟沙漏，得到9分钟
- 步骤一：同时1号、2号两个沙漏正放计时，4分钟后，1号沙漏漏完，此时把一号倒放，再经过3分钟，2号沙漏漏完。（此时1号还剩下1分钟）历时：4+3=7分钟。
- 步骤二：2号沙漏倒放，至1号沙漏的漏完，此时2号沙漏倒放已有一分钟沙漏流出。用时：1分钟。
- 步骤三：再把2号沙漏正放，等到刚刚流出的沙漏流回来，正好1分钟。 用时：1分钟。
总时间为：7+1+1=9分钟。
8. 两个烧杯，一个放糖一个放盐，用勺子舀一勺糖到盐，搅拌均匀，然后舀一勺混合物会放糖的烧杯，问你两个烧杯哪个杂质多？
答：相同。设盐和a糖最初为x 取走一勺y 而后盐中有x+y 最后盐中含糖y-y*y/(x+y) 糖中含盐y*x/(x+y) 两式相等