亚马逊面试经历 - Set 205 (校内实习)

介绍

本篇介绍的是作者在亚马逊校内实习时的面试经历。亚马逊是全球最大的电商公司之一，同时也是全球领先的云计算服务提供商。亚马逊在中国的业务发展较快，也是国内IT从业者的一个热门选择之一。

面试流程

作者进行了两轮面试，分别是电话面试和现场面试。电话面试时主要是进行技术能力的考查，具体的题目叙述如下。

题目 1

实现一个基于 Java 的线程安全的链表。

public class MyLinkedList<T> {

    private volatile Node<T> head;
    private volatile Node<T> tail;

    public MyLinkedList() {
        head = null;
        tail = null;
    }

    public void add(T value) {
        Node<T> node = new Node<>(value);

        if (head == null) {
            head = node;
            tail = node;
        } else {
            synchronized (tail) {
                tail.next = node;
                tail = node;
            }
        }
    }

    public synchronized T get(int index) {
        Node<T> node = head;

        for (int i = 0; i < index; i++) {
            node = node.next;
        }

        return node.value;
    }

    private static class Node<T> {
        T value;
        Node<T> next;

        Node(T value) {
            this.value = value;
        }
    }
}

这是一份基本的 Java 代码实现，其中使用了 synchronized 关键字保证了线程安全，但是仅仅使用这个关键字还是不能解决所有的线程安全问题。面试官根据这份代码询问了作者关于 ConcurrentHashMap，ConcurrentLinkedQueue 等线程安全集合的底层实现和使用细节。

题目 2

在一张 M x N 的网格中，每个格子可以是空地、障碍物或者终点。请输出一条从起点到终点的最短路径。其中，使用“1”表示路径中的格子，使用“0”表示其他格子。

class Solution {
    private static final int[] dx = {0, 0, 1, -1};
    private static final int[] dy = {1, -1, 0, 0};

    public int[][] findShortestPath(int[][] grid, int[] start, int[] end) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dist = new int[m][n];
        int[][] prevX = new int[m][n];
        int[][] prevY = new int[m][n];
        Queue<int[]> queue = new LinkedList<>();

        // 初始化
        for (int i = 0; i < m; i++) {
            Arrays.fill(dist[i], Integer.MAX_VALUE);
        }

        dist[start[0]][start[1]] = 0;
        queue.offer(start);

        // 广度优先搜索
        while (!queue.isEmpty()) {
            int[] curr = queue.poll();

            if (curr[0] == end[0] && curr[1] == end[1]) {
                break;
            }

            for (int i = 0; i < 4; i++) {
                int x = curr[0] + dx[i];
                int y = curr[1] + dy[i];

                if (x < 0 || x >= m || y < 0 || y >= n ||
                        grid[x][y] == 1 || dist[x][y] != Integer.MAX_VALUE) {
                    continue;
                }

                dist[x][y] = dist[curr[0]][curr[1]] + 1;
                prevX[x][y] = curr[0];
                prevY[x][y] = curr[1];
                queue.offer(new int[]{x, y});
            }
        }

        // 寻找最短路径
        List<int[]> path = new ArrayList<>();
        int currX = end[0];
        int currY = end[1];

        while (currX != start[0] || currY != start[1]) {
            path.add(new int[]{currX, currY});
            int tempX = prevX[currX][currY];
            int tempY = prevY[currX][currY];
            currX = tempX;
            currY = tempY;
        }

        path.add(start);
        Collections.reverse(path);

        // 输出结果
        int[][] result = new int[m][n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                result[i][j] = grid[i][j];
            }
        }

        for (int[] pos : path) {
            result[pos[0]][pos[1]] = 1;
        }

        return result;
    }
}

这是一份基本的 BFs 算法实现。面试官对于作者代码的时间复杂度进行了详细的考察，并提出了一些优化思路，例如：使用 A* 算法或者双向 BFS 算法等来加快计算速度。

题目 3

在一个无序数组中，找到所有的出现次数大于等于 K 的数。

public List<Integer> findKElements(int[] arr, int k) {
    List<Integer> result = new ArrayList<>();
    Map<Integer, Integer> map = new HashMap<>();

    for (int i = 0; i < arr.length; i++) {
        map.put(arr[i], map.getOrDefault(arr[i], 0) + 1);
    }

    for (int i = 0; i < arr.length; i++) {
        int count = map.getOrDefault(arr[i], 0);

        if (count >= k && !result.contains(arr[i])) {
            result.add(arr[i]);
        }
    }

    return result;
}

这是一份基本的 HashMap 实现。面试官对于作者代码的空间复杂度和时间复杂度进行了详细的考察，并提出了一些优化思路，例如：使用桶排序或者二叉树来统计出现次数。

总结

本篇介绍了作者在亚马逊校内实习时的面试经历。通过这些题目，作者学会了很多关于算法、数据结构和 Java 程序设计的知识，也认识到了自己在某些方面存在的不足。面试是一个双向选择的过程，需要考察面试官对于技术能力、代码实现和沟通能力的评估，同时也需要考察自身对于公司文化、团队配合和职业发展的认知。希望本篇能够对亚马逊求职者有所启示。