Python算法与数据结构面试题系列一（附答案_set的插入时间复杂度

1.时间复杂度问题

已知 AList = [1, 2, 3]，BSet = {1, 2, 3} (1)从AList和BSet中查找4，最坏时间复杂度哪个大？(2)从AList和BSet中插入4，最坏时间复杂度哪个大？

答:

对于查找，列表和集合的最坏时间复杂度都是O(n)，所以一样的。
列表操作插入的最坏时间复杂度为o(n), 集合为o(1)，所以Alist大。set是哈希表所以操作的复杂度基本上都是o(1)。

2. 用 Python 实现一个二分查找的函数

答:

def binary_search(arr, target):
    n = len(arr)
    left = 0
    right = n - 1
    while left <= right :
    mid = (left + right) // 2
    if arr[mid] < target:
        left = mid + 1
    elif arr[mid] > target:
        right = mid - 1
    else :
        print(f"index:{mid},value:{arr[mid]}")
        return True
    return False

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

3. Python 单例模式的实现方法\

答:

实现单例模式的方法有多种，之前再说元类的时候用 call 方法实现了一个单例模式，另外 Python 的模块就是一个天然的单例模式，这里我们使用 new 关键字来实现一个单例模式。

通过 new 函数实现简单的单例模式。

class Book:
    def __new__(cls, title):
        if not hasattr(cls, "_ins"):
            cls._ins = super().__new__(cls)
            print('in __new__')
        return cls._ins

    def __init__(self, title):
        print('in __init__')
        super().__init__()
        self.title = title

if __name__ == '__main__':
    b = Book('The Spider Book')
    b2 = Book('The Flask Book')
    print(id(b))
    print(id(b2))
    print(b.title)
    print(b2.title)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4. 使用 Python 实现一个斐波那契数列

答:
斐波那契数列:数列从第3项开始，每一项都等于前两项之和。

def fibonacci(num):
    a, b = 0, 1
    l = [a, b]
    for i in range(num):
        a, b = b, a + b
        l.append(b)
    return l

if __name__ == '__main__':
    print(fibonacci(10))
1
2
3
4
5
6
7
8
9
10

5. 找出列表中的重复数字

答:

思路：从头扫到尾，只要当前元素值与下标不同，就做一次判断，numbers[i] 与 numbers[numbers[i]] 相等就认为找到了重复元素，返回 true；否则就交换两者，继续循环。直到最后还没找到认为没找到重复元素。

# -*- coding:utf-8 -*-
class Solution:
    def duplicate(self, numbers):
        if numbers is None or len(numbers) <= 1:
            return False
        use_set = set()
        duplication = {}
        for index, value in enumerate(numbers):
            if value not in use_set:
                use_set.add(value)
            else:
                duplication[index] = value
        return duplication

if __name__ == '__main__':
    s = Solution()
    d = s.duplicate([1, 2, -3, 4, 4, 95, 95, 5, 2, 2, -3, 7, 7, 5])
    print(d)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6. 找出列表中的单个数字

答:

def find_single(l :list):
    result = 0
    for v in l:
        result ^= v
        if result == 0:
            print("没有落单元素")
        else :
            print("落单元素", result)

if __name__ == '__main__':
    l = [1, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6]
    find_single(l)
1
2
3
4
5
6
7
8
9
10
11
12

7. 写一个冒泡排序

答:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        for j in range(n - i - 1):.
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

if __name__ == '__main__':
    l = [1, 2, 3, 4, 5, 55, 6, 3, 4, 5, 6]
    bubble_sort(l)
    print(l)
1
2
3
4
5
6
7
8
9
10
11

8. 写一个快速排序

答:

def quick_sort(arr, first, last):
    if first >= last:
    return
    mid_value = arr[first]
    low = first
    high = last
    while low < high:
        while low < high and arr[high] >= mid_value:
            high -= 1  # 游标左移
            arr[low] = arr[high]

    while low < high and arr[low] < mid_value:
        low += 1
        arr[high] = arr[low]
        arr[low] = mid_value

quick_sort(arr, first, low - 1)
quick_sort(arr, low + 1, last)

if __name__ == '__main__':
    l = [1, 2, 3, 4, 5, 55, 6, 3, 4, 5, 6]
    quick_sort(l, 0, len(l) - 1)
    print(l)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

9. 写一个拓扑排序

答:

对应于该图的拓扑排序。每一个有向无环图都至少存在一种拓扑排序。

import pysnooper
from typing import Mapping

@pysnooper.snoop()
def topological_sort(graph:Mapping):
# in_degrees = {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0}
    in_degrees = dict((u, 0) for u in graph)
    for u in graph:
        for v in graph[u]:  # 根据键找出值也就是下级节点
            in_degrees[v] += 1  # 对获取到的下级节点的入度加 1
    # 循环结束之后的结果: {'a': 0, 'b': 1, 'c': 1, 'd': 2, 'e': 1, 'f': 4}
    Q = [u for u in graph if in_degrees[u] == 0]  # 入度为 0 的节点
    in_degrees_zero = []
    while Q:
        u = Q.pop()  # 默认从最后一个移除
        in_degrees_zero.append(u)  # 存储入度为 0 的节点
        for v in graph[u]:
            in_degrees[v] -= 1  # 删除入度为 0 的节点，以及移除其指向
            if in_degrees[v] == 0:
            Q.append(v)
    return in_degrees_zero

if __name__ == '__main__':
# 用字典的键值表示图的节点之间的关系，键当前节点。值是后续节点。
    graph_dict = {
            'a': 'bf',  # 表示 a 指向 b 和 f
            'b': 'cdf',
            'c': 'd',
            'd': 'ef',
            'e': 'f',
            'f': ''}

    t = topological_sort(graph_dict)
    print(t)
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

10. Python 实现一个二进制计算

答:

二进制加法

def binary_add(a:str, b: str):
    return bin(int(a, 2) + int(b, 2))[2:]

if __name__ == '__main__':
    num1 = input("输入第一个数，二进制格式:\n")
    num2 = input("输入第二个数，二进制格式:\n")
    print(binary_add(num1, num2))
1
2
3
4
5
6
7

就写到这了，希望会对大家有帮助

下面我还整理了一份软件测试工程师发展方向知识架构体系图。

希望大家能照着这个体系在1-2年内完成这样一个体系的构建。可以说，这个过程会让你痛不欲生，但只要你熬过去了。以后的生活就轻松很多。正所谓万事开头难，只要迈出了第一步，你就已经成功了一半，古人说的好“不积跬步，无以至千里。”等到完成之后再回顾这一段路程的时候，你肯定会感慨良多。

如果你不想再体验一次自学时找不到资料，没人解答问题，坚持几天便放弃的感受的话，可以关注我的公众号【程序员二黑】领取软件测试资源包，回复学习路线可以获取件测试工程师发展方向知识架构体系原图，还可以加入我们的群，785128166 大家一起讨论交流，里面也有各种软件测试资料和技术交流。

加油吧，测试员！如果你需要提升规划，那就行动吧，在路上总比在起点观望的要好。

未来的你肯定会感谢现在拼命的自己！