Java 找到數組中兩個元素相加等於指定數的所有組合

 思路1：可以用hash表來存儲數組中的元素，這樣我們取得一個數后，去判斷sum - val 在不在數組中，如果在數組中，則找到了一對二元組，它們的和為sum，該算法的缺點就是需要用到一個hash表，增加了空間復雜度。

思路2：同樣是基於查找，我們可以先將數組排序，然后依次取一個數后，在數組中用二分查找，查找sum -val是否存在，如果存在，則找到了一對二元組，它們的和為sum，該方法與上面的方法相比，雖然不用實現一個hash表，也沒不需要過多的空間，但是時間多了很多。排序需要O(nLogn)，二分查找需要(Logn)，查找n次，所以時間復雜度為O(nLogn)。

思路3：該方法基於第2種思路，但是進行了優化，在時間復雜度和空間復雜度是一種折中，但是算法的簡單直觀、易於理解。首先將數組排序，然后用兩個指向數組的指針，一個從前往后掃描，一個從后往前掃描，記為first和last，如果 fist + last < sum 則將fist向前移動，如果fist + last > sum，則last向后移動。

第三種思路是最好的。

public class Main {
    public static void main(String[] args) {
        int[] array1 = {10,2,7,4,5,6,3,8,9,1};
        int[] array2 = {1,2,3,4,5,6,7,8,9,10};
        int[] array3 = {1,2,3,4,5,6,7,8,9,10};
//        execute1(array1, 8);
//        execute2(array2, 8);
        execute3(array3, 10);
    }

    //思路：使用hash表存儲數組各元素是否存在的標志，然后遍歷數組，判斷sum與當前數組元素的差值是否在hash表中,
    //若為真則打印，該算法不要求數組有序，但要求一個hash數組的額外空間，時間復雜度是O(n)
    private static void execute1(int[] array, int m) {
        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)){
                System.out.println(array[i] + " " + tmp);
            }
        }
    }

    //思路：該方法的前提是要求數組是有序的，然后再遍歷數組，判斷sum與數組元素的差值是否在數組中，由於數組有序所以可以采用二分查找的方法
    //二分查找的時間復雜度為O(logn),排序的時間復雜度是O(nlogn),查找n次，總的時間復雜度為O(nlogn)，避免了空間的浪費
    private static void execute2(int[] array, int m) {
        for(int i = 0; i < array.length; i++) {
            int tmp = m - array[i];
            if (tmp > array[i]) {
                if (binarySearch(array, tmp) != -1) {
                    System.out.println(array[i] + " " + tmp);
                }
            }
        }
    }
    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
    private static void execute3(int[] array, int m) {
        int first = 0;
        int last = array.length -1;
        int sum = 0;
        while(first < last ) {
            sum = array[first] + array[last];
            if (sum == m) {
                System.out.println(array[first] + " " + array[last]);
                first++;
                last--;
            } else if (sum < m) {
                first++;
            } else {
                last--;
            }
        }
    }
}

 

http://blog.csdn.net/lalor/article/details/7554594

http://blog.csdn.net/pingnanlee/article/details/14168511

http://m.blog.csdn.net/article/details?id=50638593