zijie测开mianjing

1.判断链表相交

# 链表相交,两个表分别拼接，同时向后走，总相遇
def inner(head1, head2):
    cur1, cur2 = head1, head2
    while cur1 != cur2:
        if cur1: # 当前节点存在，就一直往下走
           cur1 = cur1.next
        else: # 如果不存在，紧接head2
            cur1 = head2
        if cur2:
            cur2 = cur2.next
        else:
            cur2 = head1
    return cur1
1
2
3
4
5
6
7
8
9
10
11
12
13

2.判断链表是否带环

# 判断链表是否有环，快慢指针和哈希法
def cycle(head):
    if not head or not head.next:
        return False
    seen = set() # 去重集合
    while head:
        if head in seen:
            return True
        seen.add(head)
        head = head.next
    return False

def cycle(head):
    if not head or not head.next:
        return False
    slow = head
    fast = head.next
    while slow != fast:
        if not fast or not fast.next: # 没有环，才会有这种情况fast找不到下一个节点
            return False
        slow = slow.next
        fast = fast.next
    return True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.找TOP10大的数（说出所有想法）
4.排序算法
快速排序

# 快排，摆正mid的位置
def quick_sort(alist, first, last):
    if first >= last:
        return
    mid = alist[first] # 选一个值为中间值
    low = first
    high = last
    while low < high:
        while low < high and alist[high] > mid:
            high -= 1 # high比mid大，high左移
        alist[low] = alist[high] # 如果high比mid小，赋值给alsit[low]
        while low < high and alist[low] < mid:
            low += 1
        alist[high] = alist[low]
    alist[low] = mid # 相遇的时候就是mid该在的位置
    quick_sort(alist, first, low - 1) # 递归进行左右两部分
    quick_sort(alist,low + 1, last)

li = [54,26,93,17,77,31,44,55,20]
quick_sort(li, 0, 8)
print(li)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

不稳定

冒泡排序：重复比较两个元素，如果顺序相反就交换，最坏时间复杂度o（n^2)
稳定

def bubble_sort(alist): # 冒泡
    n = len(alist)
    for j in range(n-1): # 外围
        for i in range(0, n-1-j): # i在j内部包含
            if alist[i] > alist[i + 1]: # 每次都是i和i+1进行比较
                alist[i], alist[i + 1] = alist[i +1], alist[i]

if __name__ == "__main__":
    li = [54,26,93,17,77,31,44,55,20]
    print(li)
    bubble_sort(li)
    print(li)

1
2
3
4
5
6
7
8
9
10
11
12
13

好像逻辑不太对↓

def maopao(alist):
    n = len(alist)
    for i in range(n-1):
        for j in range(i + 1, n):
            if alist[i] > alist[j]:
                alist[i], alist[j] = alist[j], alist[i]
            else:
                continue

if __name__ == "__main__":
    li = [54,26,93,17,77,31,44,55,20]
    print(li)
    print(maopao(li))
    print(li)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

选择排序:从未排序序列找到最小的元素，放在起始位置 o(n^2)
不稳定
插入排序：未排序的序列，从已排序的序列向向前扫描，插入
稳定
归并排序 :一次次的向下分，然后一次次比较向上组合
稳定
希尔排序：将待排序序列分成若干子序列，不断缩减步长，list[i]与list[i-gap]比较 O(nlogn)
不稳定

二分查找

def erfen(alist, target):
    n = len(alist)
    if n > 0:
        mid = n // 2
        if alist[mid] == target:
            return True
        elif alist[mid] < target:
            return erfen(alist[mid + 1:], target)
        else:
            return erfen(alist[:mid], target)
    return False

if __name__=="__main__":
    alist= [34,67,89,90]
    print(erfen(alist, 89))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.List,set,map区别 --java
6.软件测试流程
7.设计登录功能

8、1000瓶酒.10只老鼠.有一瓶酒有毒,每只老鼠可以喝无限多的酒,如何测一次就找出哪瓶酒有毒
二进制 2^10=1024<1000 所以可以都让老鼠喝

9、对于数组data，满足|data[i]-data[i+1]|=1,此时从data中索引某个值，问最快的方法是什么？比如说：data=[1,2,3,4,3,2,3,4,5,4]这样，索引第一个出现的3所在的位置，最快的方式是什么。

data[0] 确定多少，然后找到与目标值差值cha得到data[0 + cha]为多少继续查找，再看差值
以cha为gap进行查找

先去data[0]，看data[0]和目标值（target）的差(delta)的绝对值是多少，然后下一个索引到data[0+delta]，再看data[0+delta]和target的差的绝对值（delta）是多少，这样使用可变步长进行索引，应该就对了

3.（算法）给一个int型矩阵，求里面全为1的最大的n*m的子矩阵
4.（算法）如何判断两个单链表是否相交？
分别向后拼凑，如果相交，一定会有公共元素

def inner(head1, head2):
    cur1 = head1
    cur2 = head2
    while cur1 != cur2:
        if cur1:
            cur1 = cur1.next
        else:
            cur1 = head2
        if cur2:
            cur2 = cur2.next
        else:
            cur2 = head1
    return cur1
1
2
3
4
5
6
7
8
9
10
11
12
13

5.（算法）一个字符串按照k步长分组，再进行反转。python5行内实现

class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        hair = ListNode(0) # 确定一个虚拟的头节点
        hair.next = head # 虚拟放在整个链表的头部
        pre = hair # pre指向虚拟节点

        while head: # 遍历整个链表
            tail = pre # 先另尾部等于pre
            for i in range(k): # 查看剩余长度是否大于k，不大于的话，就直接返回原来的链表
                tail = tail.next# 下一个tail=tail的下一个节点
                if not tail: # 如果没有tail了
                    return hair.next
            tmp = tail.next # 当前tail的下一个元素记一个临时值
            head, tail = self.reverse(head, tail) # 头尾调转
            # 把子链表重新连接回原链表
            pre.next = head # 首节点的下一个节点是反转之后的头
            tail.next = tmp # 尾的下一个是反转前的tail的下一个
            pre = tail # 下一个的头是当前的尾
            head = tail.next # head是下一个链表的头，是当前尾部的下一个元素
        return hair.next


    def reverse(self, head, tail): # 先创建一个反转链表的函数
        if not head or not head.next:
            return head
        cur = head
        pre = tail.next # 其实等于None
        while pre != tail: # 当pre和末尾不相等时，一直循环
            tmp = cur.next # 临时值=cur的下一个值
            cur.next = pre # cur的下一个值等于开头
            pre = cur # pre往后挪
            cur = tmp # cur往后挪
        return tail, head # 返回头和尾部节点

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
29
30
31
32
33
34

反转链表

def fanzhuan(head):
    if not head:
        return None
    if not head.next:
        return head
    tmp = fanzhuan(head.next)
    head.next.next = head
    head.next = None
    return tmp

def fanzhuan(head):
    pre = None
    cur = head
    while cur:
        tmp = cur.next
        cur.next = pre
        pre = cur
        cur = tmp
    return pre
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

9.(算法)最长公共子序列

def zuichang(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[-1][-1]
1
2
3
4
5
6
7
8
9
10
11

10.(算法)爬楼梯

# 动态规划
class Solution:
    def climbStairs(self, n: int) -> int:
        ret = [0] * (n + 1)
        ret[0] = 1 # 第0个位置是1
        ret[1] = 1 # 第一个位置也是1
        for i in range(2, n + 1): # 从第二个开始，是前两个之和
            ret[i] = ret[i - 1] + ret[i - 2]
        return ret[n]
1
2
3
4
5
6
7
8
9

# 暴力深度递归
class Solution:
    def climbStairs(self, n: int) -> int:
        a = 0
        b = 1
        c = 0
        for i in range(n):
            c = a + b
            a = b
            b = c
        return c


1
2
3
4
5
6
7
8
9
10
11
12
13

11.如何测试微信视频聊天功能
12.二叉树如何按照之字型打印.(用队列啊,这题经常被问感觉)

4.(算法题)如何最高效率判找到N以下的所有质数
5.(算法题)数列最高得分

11.linux日志搜索和替换命令和查找文件命令
第一种：查看实时变化的日志

tail -f 文件名（默认最后10行，相当于增加参数 -n 10）
ctrl + c 是退出tail 命令
1
2

其他情况:

tail -n 20 filename (显示filename最后20行)
tail -n +5 filename (从第5行开始显示文件)
1
2

第二种：搜索关键字附近的日志

cat -n filename |grep "关键字"
1

———————————————
原文链接：https://blog.csdn.net/A___B___C/article/details/92792515

12.怎么对待加班
13.项目由于rd原因使进度拖延，但是必须按规定时间点上线，测试怎么做
14.日志搜索
15.请求一个url，页面返回失败，怎么定位是前端还是后端原因？
软件测试过程中经常被问到怎么判断是前端问题还是后端问题，主要是通过抓包查看请求响应是否与接口文档一致。
1.如果请求数据与接口文档不一致，则是前端问题
2.如果请求数据与接口文档一致，响应数据与接口文档也一致，则是前端问题
3.如果请求数据与接口文档一致，响应数据与接口文档不一致，则是后端问题
————————————————

字节跳动测试开发二面：

热乎乎面经：19：11
1、header里面有什么

2、body里面各种都代表什么含义
postman
在URL输入ip+端口+路径 ，请求有两种方式post,get请求根据接口文档选择，
get请求只能在params填写参数，
post可以在body/form-data填写请求，
还可以在raw里填写json格式请求
Postman单接口工具
在没有拿到接口文档以前先部署环境（tomcat服务运行–war–webapps–启动tomcat再进入解压后的程序包web-inf—class–properties—kap.properties----jdbc进行配置数据（数据值、其它路径）—启动tomcat–在浏览器输入ip+端口访问软件
先看请求post、get请求
post请求输入路径-在body中输入参数-即可
get请求输入路径-直接输入参数-值就可以
如果是json串直接输入json格式就可以
断言-在test中增加（正数第六个倒数第四个）–增加断言结果
post请求地址与数据分离 安全 不可存到历史记录中
get请求地址数据全在URL 不安全 可存到历史记录中

3、cooikes和session区别
4、http有哪些方法
5、git的方法和原理：

git pull / git clone
git add # 将工作区保存再暂存区
git commit # 把暂存区的修改做一次版本记录
git push # 将该分支所有本地推到远程仓库
1
2
3
4

git commit没想起来 整个流程忘记了，还是要精通简历上写的
台阶法：时间复杂度，空间复杂度

# 台阶
# 递归，会涉及大量的重复计算
# 时间复杂度时o(2^n) 空间复杂度：递归栈的空间
def stair(n):
    if n <= 2:
        return n
    return (stair(n - 1) + stair(n - 2))
print(stair(5))
1
2
3
4
5
6
7
8

# 动态规划:直接从子树得到答案，过程是自下向上
# 时间复杂度 o(n) 空间复杂度 o(n)
def stair(n):
    dp = [0] * (n + 1) # dp[0,1,2,  ,n]
    dp[0] = 1
    dp[1] = 1
    for i in range(2, n + 1): # 2, 3, 4, , n
        dp[i] = dp[i - 1] + dp[i - 2]
    return dp[n]

1
2
3
4
5
6
7
8
9
10

# 继续优化
# 时间复杂度是o(n)
# 空间复杂度 o(1) 没有多余闲置的空间
def stair(n):
    a = 0
    b = 1
    c = 0
    for i in range(n):
        c = a + b
        a = b
        b = c
    return c
1
2
3
4
5
6
7
8
9
10
11
12

6、python的迭代器，定义一个add函数是a + b 然后再定义一个add2进行输出
分治法，递归法了解，知道自己解题用的方法
7、问项目？

字节跳动测试开发：

一面：
一组数字中，找到出现次数为2的，需要o(n)时间复杂度
其中面试的时候用了python自带的内置函数进行计算

def find_two(lst):
    tmp = set(lst) # 先去去重
    ret = [] # ret保存出现两次的数字
    for i in tmp:
        if lst.count(i) == 2:
            ret.append(i)
        else:
            continue
    return ret
1
2
3
4
5
6
7
8
9

def find_two(lst):
    map = {}
    for i in lst:
        if i in map:
            map[i] += 1
        else:
            map[i] = 1
    ret = []
    for key, value in map.items():
        if value == 2:
            ret.append(key)
        else:
            continue
    print(ret)

if __name__ == "__main__":
    lst = [3,4,2,5,4,2,6]
    find_two(lst)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

项目

两个sql语句
1、找到当前公司薪水排第二名的员工姓名

select name from department order by salary desc limit 2,1
1

2、找到当前公司薪水排第二名的所有的员工姓名

select name from department where salary = (select max(salary) from (select * from department where salary not in max(salary)))
1

linux语言：知道端口号，查日志文件在哪？？？
查看当前有哪些进程

# 查看当前系统的进程情况
ps -aux
ps -ef
# 查看服务器某个端口的占用情况
lsof -i： 8080
netstat tunlp | grep 8080

# 查看日志
tail -f  # 默认看最后10行数据，并且实时更新
tail -n 20 filename  # 看最后20行日志

# 杀死进程
kill -9 pid  
1
2
3
4
5
6
7
8
9
10
11
12
13

腾讯测试开发一面面经

1、根据进程名查看进程号

# 根据进程名查看进程id
ps aux | grep 进程名
ps -ef | grep 进程名

# 通过进程id查看端口号
netstat tunlp | grep pid

# 通过端口号查看占用进程id
netstat nap | grep 端口号
1
2
3
4
5
6
7
8
9

2、会不会接口测试
3、项目细节
4、平衡二叉树

# 平衡二叉树
def isbalance(root):
    if not root:
        return True
    return isbalance(root.left) and isbalance(root.right) and abs(depth(root.left) - depth(root.right)) <= 1

def depth(root):
    if not root:
        return 0
    return max(depth(root.left), depth(root.right)) + 1
1
2
3
4
5
6
7
8
9
10

5、最长子序列 测试用例的设计
[100,400,2,54,3,7,6,4,5] == > [3,4,5,6]是最长子序列，不考虑顺序

def maxlength(lst):
    if not lst:
        return 0
    lst.sort()
    n = len(lst)
    count = 1
    res = 1
    for i in range(n - 1):
        if lst[i] + 1 == lst[i + 1]:
            count += 1
            res = max(res, count)
        else:
            count = 1
    return res

lst = [100,400,2,54,3,7,6,4,5]
print(maxlength(lst))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6、链表和数组的区别
二者都属于一种数据结构
从逻辑结构来看

1. 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费；数组可以根据下标直接存取。

2. 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项，非常繁琐）链表必须根据next指针找到下一个元素

数组的优点
随机访问性强
查找速度快
数组的缺点
插入和删除效率低
可能浪费内存
内存空间要求高，必须有足够的连续内存空间。
数组大小固定，不能动态拓展
链表的优点
插入删除速度快
内存利用率高，不会浪费内存
大小没有固定，拓展很灵活。
链表的缺点
不能随机查找，必须从第一个开始遍历，查找效率低
————————————————
链表和数组

7、索引的理解 优缺点
索引是对数据库表中的一列或者多列的值进行排序的一种数据结构，如果把数据库中的表比作一本书，索引就是这本书的目录，通过目录可以快速查找到书中指定内容的位置。
优点：
a）可以保证数据库表中每一行的数据的唯一性。
b）可以大大加快数据的索引速度。
c）加速表与表之间的连接，特别是在实现数据的参考完事性方面特别有意义。
d）在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
f）通过使用索引，可以在时间查询的过程中，使用优化隐藏器，提高系统的性能。
缺点：
a) 创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
b) 索引需要占物理空间，除了数据表占用数据空间之外，每一个索引还要占用一定的物理空间，如果需要建立聚簇索引，那么需要占用的空间会更大。
c) 以表中的数据进行增、删、改的时候，索引也要动态的维护，这就降低了整数的维护速度。
d) 建立索引的原则。
e) 在经常需要搜索的列上，可以加快搜索的速度。
f) 在作为主键的列上，强制该列的唯一性和组织表中数据的排列结构。

8、Linux命令

一面：
一组数字中，找到出现次数为2的
项目
两个sql语句
linux语言：知道端口号，查日志文件在哪

滴滴测开一面

姓名 科目 科目成绩
select xingming,sum(grade)
[6,6,6,1,2,3,1,3,4,4,3,2,1,7,8]

回文数： 如果有多个，怎么找长度最长的回文数
冒泡排序的空间复杂度：
编辑界面：
更改用户权限：chmod
替换某个文件的内容：
sed用法实例
替换操作：s命令
替换文本中的字符串：

sed ‘s/book/books/’ file
-n选项和p命令一起使用表示只打印那些发生替换的行：
sed -n ‘s/test/TEST/p’ file
直接编辑文件选项-i，会匹配file文件中每一行的第一个book替换为books：
sed -i ‘s/book/books/g’ file
全面替换标记g
使用后缀 /g 标记会替换每一行中的所有匹配：
sed ‘s/book/books/g’ file
查找日志，进行定时：

圆珠笔：
ui:

智力：
筷子100
两个人抓筷子 每个人只能抓1-6根，
我开始抓，保证最后一根我抓 100/7 = 14 …2
16
1, 6,1 ,5,2

25只小乌龟 赛跑：只允许5只，怎么能找到跑的最快的三只

服务端： 工程+技术 100% 覆盖服务+平台
压测
接口测试 功能测试
技术项：策略服务 算法
数据（分析） 持续集成：准入准出测试开发