测开面试常用算法

Posted 2021-05-05 雨子杂说

最近小姐姐面试“测试开发工程师”岗位，算法这关现在是“测试开发工程师”必备技能，总结了下常用算法

1、冒泡排序（Bubble Sort）
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1.1 算法描述
    比较相邻的元素。如果第一个比第二个大，就交换它们两个；
    对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
    针对所有的元素重复以上的步骤，除了最后一个；
    重复步骤1~3，直到排序完成。
'''
#冒泡排序，两元素互换
#时间复杂度 O(n^2)
def bubbleSort(arr):
    for i in range(len(arr)):
        for j in range(len(arr)-1-i):
            if arr[j]>arr[j+1]:
                arr[j+1],arr[j]=arr[j],arr[j+1]
 return arr

'''
2、选择排序（Selection Sort）
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
2.1 算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
    初始状态：无序区为R[1..n]，有序区为空；
    第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
    n-1趟结束，数组有序化了。
'''
def selectSort(lst):
            new=[]
            for i in range(len(lst)):
                min_value = min(lst)
                min_index = lst.index(min_value)
                new.append(lst.pop(min_index))
            return new



插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
3.1 算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
    从第一个元素开始，该元素可以认为已经被排序；
    取出下一个元素，在已经排序的元素序列中从后向前扫描；
    如果该元素（已排序）大于新元素，将该元素移到下一位置；
    重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
    将新元素插入到该位置后；
    重复步骤2~5。
'''
def insertionSort(arr):
    arr_len=len(arr)
    for i in range(arr_len):
        preIndex=i-1
        current=arr[i]
        while (preIndex>=0 and arr[preIndex]>current):
            arr[preIndex+1]=arr[preIndex]
            preIndex=preIndex-1
            arr[preIndex+1]=current
    return arr
arr=[3,38,44,4]
print (insertionSort(arr))

4、快速排序（Quick Sort）
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
4.1 算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
    从数列中挑出一个元素，称为 “基准”（pivot）；
    重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
    递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
    快速排序 时间复杂度 O(nlog2n)
'''
def quickSort(array):
    if len(array)<2:
        return array
    else:
        pivot=array[0]
        less=[i for i in array[1:] if i<=pivot]
        greater=[i for i in array[1:] if i>pivot]
        return quickSort(less)+[pivot]+quickSort(greater)
print (quickSort([10,6,5,12]))




5、二分查找二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
def banary_search(list,item):
    low=0
    high=len(list)-1
    while low<=high:
        mid=int((low+high)/2)
        guess=list[mid]
        if guess==item:
            return mid
        elif guess>item:
            high=mid-1
        else:
            low=mid+1
    return None
my_list=[1,3,5,7,9]
print (banary_search(my_list,3))
print (banary_search(my_list,-1))


6、跳台阶（zijie笔试题）
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

def jumpFloor(number):
    a=0
    b=1
    for i in range(1,number+1):
        a,b=b,a+b
 return b


7、找出序列里出现次数最多的元素和index(meituan)
def findMaxRepeatElement(arr):
    new_dict ={}
    for item in arr:
        if item not in list(new_dict.keys()):
            new_dict[item] = 1
        else:
            new_dict[item]= new_dict[item]+1
    print (new_dict)
    max_item=sorted(new_dict.items(),key=lambda x:x[1],reverse=True)[0]
 return max_item

arr=[1,2,1,2,4,1]
max_item=findMaxRepeatElement(arr)
print (max_item)


8、要求：去掉列表中重复的元素,ID不改变（zijie）
list1 = [1,2,3,4,5,5,3,1,0]
result = list(set(list1))
print (result)

9、判断iP地址是不是ipv4 或者 ipv6(58)
def  is_ipv4(ip):
    '''
    检查ip是否合法
    :param: ip ip地址
    :return: True 合法 False 不合法
    '''
    return True if [1]*4 == [ x.isdigit() and 0<=int(x)<=255 for x in ip.split(".")] else False
print(is_ipv4("192.168.1.2a0"))
print (is_ipv4("192.168.1.200"))



10、列表里，偶数排在前面，奇数排在后面（58）
def sortList(arr):
    # 使用lambda，第一种方法，
    # 先筛选出所有偶数，
    m = list(filter(lambda x: x % 2 == 0, arr))
    # 筛选出所有奇数
    n = list(filter(lambda x: x % 2 != 0, arr))
    # 按顺序拼接列表
    n.extend(m)
    # 如下也可以拼接列表
    # n += m
 return n

11、序列里，奇数排在index为奇数的位置，偶数排在index为偶数的位置（58）
def sortList2(arr):
    # 使用lambda，第一种方法，
    # 先筛选出所有偶数，
    m = list(filter(lambda x: x % 2 == 0, arr))
    # 筛选出所有奇数
    n = list(filter(lambda x: x % 2 != 0, arr))
    old=m+n
    new=[]
    for i in range(len(m+n)):
        if i%2==0:
            new.append(m.pop(0))
        else:
            new.append(n.pop(0))
    return new
a=[1,2,3,4]
print (sortList2(a))


12、处理接口返回值（json，html,xml）
from bs4 import BeautifulSoup
import requests
import os
def testHtmlParser():
    r=requests.get("http://python123.io/ws/demo.html")
    demo=r.text
    soup=BeautifulSoup(demo,"html.parser")
    content=soup.prettify()
    file =os.path.join(os.getcwd(),"parser_result.txt")
    with open(file,'w') as f:
        f.write(content)
testHtmlParser()




##处理接口html数据(meituan)
import requests
import os
import traceback
import json
def testBaidu():
    file=os.path.join(os.getcwd(),"result.txt")
    payload = {'wd':'xx'}
    url = 'http://www.baidu.com/s'
    try:
        re=requests.get(url,params=payload)
        content = re.content
        content = content.decode("utf-8")
        if re.status_code==200:
            with open (file,'w+') as f:
                f.write(content)
    except:
        err=traceback.format_exc()
        print (err)
testBaidu()



def testBaidu2():
    file=os.path.join(os.getcwd(),"result2.txt")
    payload = {'wd':'xx'}
    url = 'http://www.baidu.com/s'
    try:
        re=requests.get(url,params=payload)
        #content = re.content
        #content = content.decode("utf-8")
        content = re.text
        soup = BeautifulSoup(content,'html.parser')
        content = soup.prettify()
        if re.status_code==200:
            with open (file,'w') as f:
                f.write(content)
    except:
        err=traceback.format_exc()
        print (err)
testBaidu2()


##处理接口json数据(meituan)
import requests
def testJsonParser():
    re =requests.get("https://api.github.com/events")
    result=re.json()
    print (result)
    print (type(result))
testJsonParser()
##########美团面试题引申，处理接口xml数据
import requests
from xml.etree import ElementTree
url_str ='http://www.webxml.com.cn//webservices//qqOnlineWebService.asmx//qqCheckOnline?qqCode=%s'%'811168348'
re = requests.get(url_str)
node =ElementTree.XML(re.text.encode('utf-8'))
if node.text =='Y':
    print ("QQ在线:811168348")
else:
 print("QQ离线:811168348")

13、读文件，文件的内容是只包含数字和字符的字符串，统计字符串中字符出现的频数，并且输出频数前10 的字符
（58）
def countStrFromFile(file):
    with open (file,'r') as f:
        content=f.read()
    print (content)
    print (type(content))
    dict_str={}
    for item in content:
        try:
            int(item)
        except Exception as e:
            if item !='\n':
                if item not in dict_str.keys():
                    dict_str[item] = 0
                else:
                    dict_str[item] = dict_str[item]+1
    result=sorted(dict_str.items(),key=lambda x:x[1],reverse=True)
    a=list(map(lambda x:x[0],result))
 return (result[:10],a[:10])


14、#装饰器
import time
def timing(func):
    def wrapped(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        end = time.time()
        print ("cost:"+str(int(end-start)))
 return wrapped


@timing
def test():
    time.sleep(1)
test()

import traceback
def retry(max_count=1):
   def dec(func):
      def wraped(*argv, **kwgs):
         count = max(max_count, 1)
         for i in range(count):
            try:
               # print func.__name__+"()"
               func(*argv, **kwgs)
               break
            except Exception as e:
               msg = traceback.format_exc()
               print (msg)
               # print msg  #可打印错误信息
               if i == count - 1:
                  raise e
               else:
                  continue
      wraped.__name__ = func.__name__
      wraped.__doc__ = func.__doc__
      return wraped

   return dec



@retry(3)
def downloadImage2():
   url='https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1540104256514&di=76926c8b87e258e098301acff289c8d8&imgtype=jpg&src=http%3A%2F%2Fimg0.imgtn.bdimg.com%2Fit%2Fu%3D934220340%2C2969578747%26fm%3D214%26gp%3D0.jpg'
   reponse=requests.get(url,stream=True)
   from contextlib import closing
   ##文件流方式传输
   with closing(requests.get(url,stream=True)) as reponse:
      with open ("dome1.jpg","wb") as fd:
         for item in reponse.iter_content(128):
            fd.write(item)
downloadImage2()


15、列表，字典排序
person = {"li":18,"wang":50,"zhang":20,"sun":22}
m="li"
for key in person.keys():
    if person[key]>person[m]:
        m=key
print (m,person[m])
data_list = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
new =sorted(data_list,key=lambda  x:x['age'],reverse=True)
print (new)



16、实现 int sqrt(int x) 函数。（meituan）

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2
示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

class Solution(object):
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        left=0
        right=x//2+1
        while left<right:
            mid = left+(right-left+1)//2
            if mid*mid<x:
                left=mid
            elif mid*mid>x:
                right=mid-1
            elif mid*mid==x:
                return mid
        return left




17、#输出不重复的三位数（aiqiyi）
listA=[1,2,3,4]
for i in listA:
    for j in listA:
        for k in listA:
            if i!=j and j!=k and i!=k:
 print (i,j,k)