package com.algorithm.hash;

public class alg1 {
	public static void main(String argv[]) {
		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};
		alg1.execute1(array1, 8);
		alg1.execute2(array2, 8);
		alg1.execute3(array3, 8);
	}
	
	//思路：使用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