当前位置:   article > 正文

zijie测开mianjing

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% 覆盖服务+平台
压测
接口测试 功能测试
技术项:策略服务 算法
数据(分析) 持续集成:准入准出测试开发

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/你好赵伟/article/detail/682468
推荐阅读
相关标签
  

闽ICP备14008679号