亚马逊面试经历|设置 261（对于 SDE1）

在亚马逊 SDE1 的面试中，通常会被要求解决一些关于算法和数据结构的问题。以下是我的亚马逊面试经历：

面试1

我被问及如何实现前缀树并给出其时间和空间复杂度。我简单地解释了前缀树数据结构，并提供了一个对应代码片段：

class TrieNode:
    def __init__(self):
        self.links = [None] * 26
        self.is_end_of_word = False

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def _char_to_index(self, ch):
        return ord(ch) - ord('a')

    def insert(self, word: str) -> None:
        current = self.root
        for c in word:
            index = self._char_to_index(c)
            if not current.links[index]:
                current.links[index] = TrieNode()
            current = current.links[index]
        current.is_end_of_word = True

    def search(self, word: str) -> bool:
        current = self.root
        for c in word:
            index = self._char_to_index(c)
            if not current.links[index]:
                return False
            current = current.links[index]
        return current.is_end_of_word

    def starts_with(self, prefix: str) -> bool:
        current = self.root
        for c in prefix:
            index = self._char_to_index(c)
            if not current.links[index]:
                return False
            current = current.links[index]
        return True

时间复杂度为 O(n)，其中 n 是要插入的字符串的长度。空间复杂度为 O(n)，其中 n 是所有被插入的字符串的长度之和。

面试2

我被要求在不使用额外空间的情况下，重新排列一个数组，使得其中顺序排列的 0 和非 0 整数和之间没有间隔。我提供了以下解决方案：

def move_zeros(nums: List[int]) -> None:
    i, j = 0, 0
    while j < len(nums):
        if nums[j] != 0:
            nums[i], nums[j] = nums[j], nums[i]
            i += 1
        j += 1

这个算法的时间复杂度为 O(n)，其中 n 是数组的长度。由于它不使用额外空间，空间复杂度为 O(1)。

面试3

我被要求用 Python 编写一个函数，该函数接受一个整数矩阵作为输入，并旋转该矩阵 90 度。我提供了以下代码：

def rotate(matrix: List[List[int]]) -> None:
    n = len(matrix)

    # Transpose the matrix
    for i in range(n):
        for j in range(i, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

    # Reverse each row
    for i in range(n):
        matrix[i].reverse()

此算法的时间复杂度为 O(n^2)。它的空间复杂度为 O(1)，因为它只使用常数级别的额外空间。

面试4

我被问及如何实现哈希表并给出其时间和空间复杂度。我解释了哈希表的基本概念，并提供了一个对应的伪代码片段：

class Entry:
    def __init__(self, key, value):
        self.key = key
        self.value = value

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [[] for _ in range(size)]

    def _hash_function(self, key):
        return key % self.size

    def put(self, key, value):
        hash_value = self._hash_function(key)
        for entry in self.table[hash_value]:
            if entry.key == key:
                entry.value = value
                return
        self.table[hash_value].append(Entry(key, value))

    def get(self, key):
        hash_value = self._hash_function(key)
        for entry in self.table[hash_value]:
            if entry.key == key:
                return entry.value
        return None

时间复杂度取决于哈希函数的效率，通常可以在 O(1) 时间内进行插入和查找。空间复杂度取决于要插入的键和值的总数量。