image.png
    1、暴力破解法
    暴力破解，时间复杂度O(n²)

    1. public class Test {
    3.     public static void main(String[] args) {
    4.         System.out.println(Arrays.toString(solution(new int[]{1,2,3,4,6,5}, 10)));
    5.     }
    7.     /**
    8.      * 暴力破解，时间复杂度O(n²)
    9.      * @param numbers
    10.      * @param target
    11.      * @return
    12.      */
    13.     private static int[] solution(int[] numbers, int target) {
    14.         for (int i = 0; i < numbers.length - 1; i++) {
    15.             for (int j = i + 1; j < numbers.length; j++) {
    16.                 if (numbers[i] + numbers[j] == target) {
    17.                     return new int[]{i , j};
    18.                 }
    19.             }
    20.         }
    21.         return new int[]{0};
    22.     }
    23. }

    2、缓存标记法
    使用一个hashmap来缓存数据，用空间换时间
    时间复杂度O(n)，空间复杂度也是O(n)

    public class Test {

    public static void main(String[] args) {
        System.out.println(Arrays.toString(solution1(new int[]{1,2,3,4,6,5}, 10)));
    }

    /**
     * 使用一个hashmap来缓存数据，用空间换时间
     * 时间复杂度O(n)，空间复杂度也是O(n)
     * @param numbers
     * @param target
     * @return
     */
    private static int[] solution1(int[] numbers, int target) {
        Map<Integer, Integer> map = new HashMap();
        for (int i = 0; i < numbers.length; i++) {
            if (map.containsKey(target - numbers[i])) {
                return new int[]{map.get(target - numbers[i]), i};
            }
            map.put(numbers[i], i);
        }
        return new int[]{0};
    }

}