题目大意：

  找到数组中两个元素相加等于指定数的所有组合

情况一：给定数组中不含重复元素，且均为正整数

思路：

  使用Hash表存储数组各元素是否存在的标志，然后遍历数组，判断sum与当前数组元素的差值是否在hash表中。时间复杂度为O（n）,空间复杂度为O（n）。

代码实现：

 private static List<List<Integer>> execute1(int[] array, int m) {
        List<List<Integer>> rst = new ArrayList<>();
        List<Integer> subList = new ArrayList<>();
        int size = array.length;
        int hash[] = new int[size];
        for(int i = 0; i < size; i++) {
            hash[array[i]%size] = 1;
        }

        for(int i = 0; i < size; i++) {
            int tmp = m - array[i];
            if((tmp > array[i]) && (hash[tmp%size] == 1)){
                subList.clear();
                subList.add(array[i]);
                subList.add(tmp);
                rst.add(new ArrayList<>(subList));
            }


        }
        return rst;
    }

情况二：给定数组是有序的

思路：

  遍历数组，判断sum与数组元素的差值是否在数组中，由于数组有序可以采用二分查找的方法。二分查找的时间复杂度为O(logn),查找n次，总的时间复杂度为O(nlogn)，避免了空间的浪费

代码实现：

  private static  List<List<Integer>> execute2(int[] array, int m) {
        List<List<Integer>> rst = new ArrayList<>();
        List<Integer> subList = new ArrayList<>();
        for(int i = 0; i < array.length; i++) {
            int tmp = m - array[i];
            if (tmp > array[i]) {
                if (binarySearch(array, tmp) != -1) {
                    subList.clear();
                    subList.add(array[i]);
                    subList.add(tmp);
                    rst.add(new ArrayList<>(subList));
                }
            }
        }
        return rst;
    }
    private static int binarySearch(int[] array, int key) {
        if (array.length == 0) {
            return -1;
        }

        int first = 0;
        int last = array.length -1;

        int mid;
        while(first <= last) {
            mid = (first + last) / 2;
            if (array[mid] == key) {
                return mid;
            } else if (array[mid] < key) {
                first = mid + 1;
            } else {
                last = mid -1;
            }
        }
        return -1;
    }

情况三：给定数组是有序的

思路：

  使用两个指针，分别指向最后一个元素和第一个元素，判断它们的和是否等于sum，若等于则添加到返回链表，并且first向后移动，last向前移动；若它们的和小于sum，则说明first太小了，需要first向后移动；若它们的和大于sum，则说明last太大了，需要last向前移动，直到last>=first。时间复杂度为O（n）

代码实现：

 private static List<List<Integer>> execute3(int[] array, int m) {
        List<List<Integer>> rst = new ArrayList<>();
        List<Integer> subList = new ArrayList<>();
        int first = 0;
        int last = array.length -1;
        int sum = 0;
        while(first < last ) {
            sum = array[first] + array[last];
            if (sum == m) {
                subList.clear();
                subList.add(array[first]);
                subList.add(last);
                rst.add(new ArrayList<>(subList));
                first++;
                last--;
            } else if (sum < m) {
                first++;
            } else {
                last--;
            }
        }
        return rst;
    }