Android面试算法大全：掌握这些，面试官拜服！

2023-12-09 19:22:48

前言

作为一名Android开发人员，掌握算法和数据结构是面试中至关重要的环节。这些知识不仅是面试的敲门砖，更是开发出色应用程序的基础。为了帮助广大Android开发者备战面试，本文汇总了常见的Android面试算法题，并提供了详细的Java实现。

数据结构

1. 数组

面试题： 给定一个整数数组，找出其中不重复的元素。

public int[] findUniqueElements(int[] nums) {
    Set<Integer> set = new HashSet<>();
    for (int num : nums) {
        set.add(num);
    }
    return set.stream().mapToInt(Integer::intValue).toArray();
}

2. 链表

面试题： 反转一个单链表。

public ListNode reverseLinkedList(ListNode head) {
    ListNode prev = null;
    ListNode current = head;
    while (current != null) {
        ListNode next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    return prev;
}

3. 队列

面试题： 实现一个循环队列，支持先进先出和后进后出。

public class CircularQueue<T> {
    private int head;
    private int tail;
    private T[] items;

    public CircularQueue(int capacity) {
        items = (T[]) new Object[capacity];
    }

    public void enqueue(T item) {
        if ((tail + 1) % items.length == head) {
            throw new IllegalStateException("Queue is full");
        }
        items[tail] = item;
        tail = (tail + 1) % items.length;
    }

    public T dequeue() {
        if (head == tail) {
            throw new IllegalStateException("Queue is empty");
        }
        T item = items[head];
        head = (head + 1) % items.length;
        return item;
    }
}

4. 栈

面试题： 用两个栈实现一个队列。

public class StackQueue<T> {
    private Stack<T> stack1;
    private Stack<T> stack2;

    public StackQueue() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }

    public void enqueue(T item) {
        stack1.push(item);
    }

    public T dequeue() {
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}

排序算法

1. 冒泡排序

面试题： 给定一个整数数组，使用冒泡排序对其进行升序排序。

public void bubbleSort(int[] nums) {
    for (int i = 0; i < nums.length - 1; i++) {
        boolean swapped = false;
        for (int j = 0; j < nums.length - i - 1; j++) {
            if (nums[j] > nums[j + 1]) {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
                swapped = true;
            }
        }
        if (!swapped) {
            break;
        }
    }
}

2. 选择排序

面试题： 给定一个整数数组，使用选择排序对其进行降序排序。

public void selectionSort(int[] nums) {
    for (int i = 0; i < nums.length - 1; i++) {
        int maxIndex = i;
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[j] > nums[maxIndex]) {
                maxIndex = j;
            }
        }
        int temp = nums[i];
        nums[i] = nums[maxIndex];
        nums[maxIndex] = temp;
    }
}

3. 插入排序

面试题： 给定一个整数数组，使用插入排序对其进行从小到大排序。

public void insertionSort(int[] nums) {
    for (int i = 1; i < nums.length; i++) {
        int key = nums[i];
        int j = i - 1;
        while (j >= 0 && nums[j] > key) {
            nums[j + 1] = nums[j];
            j--;
        }
        nums[j + 1] = key;
    }
}

动态规划

1. 斐波那契数列

面试题： 实现斐波那契数列的动态规划解法。

public int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    int[] memo = new int[n + 1];
    memo[0] = 0;
    memo[1] = 1;
    for (int i = 2; i <= n; i++) {
        memo[i] = memo[i - 1] + memo[i - 2];
    }
    return memo[n];
}

2. 最长公共子序列

面试题： 给定两个字符串，找出它们的最长公共子序列。

public int longestCommonSubsequence(String s1, String s2) {
    int[][] dp = new int[s1.length() + 1][s2.length() + 1];
    for (int i = 0; i <= s1.length(); i++) {
        for (int j = 0; j <= s2.length(); j++) {
            if (i == 0 || j == 0) {
                dp[i][j] = 0;
            } else if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
    return dp[s1.length()][s2.length()];
}