java实现 数组中两个元素相加等于指定数的所有组合

 

1. package com.algorithm.hash;
2. public class alg1 {
3. public static void main(String argv[]) {
4. int[] array1 = {10,2,7,4,5,6,3,8,9,1};
5. int[] array2 = {1,2,3,4,5,6,7,8,9,10};
6. int[] array3 = {1,2,3,4,5,6,7,8,9,10};
7. alg1.execute1(array1, 8);
8. alg1.execute2(array2, 8);
9. alg1.execute3(array3, 8);
10. }
11. //思路：使用hash表存储数组各元素是否存在的标志，然后遍历数组，判断sum与当前数组元素的差值是否在hash表中,
12. //若为真则打印，该算法不要求数组有序，但要求一个hash数组的额外空间，时间复杂度是O(n)
13. private static void execute1(int[] array, int m) {
14. int size = array.length;
15. int hash[] = new int[size];
16. for(int i = 0; i < size; i++) {
17. hash[array[i]%size] = 1;
18. }
19. for(int i = 0; i < size; i++) {
20. int tmp = m - array[i];
21. if((tmp > array[i]) && (hash[tmp%size] == 1)){
22. System.out.println(array[i] + " " + tmp);
23. }
24. }
25. }
26. //思路：该方法的前提是要求数组是有序的，然后再遍历数组，判断sum与数组元素的差值是否在数组中，由于数组有序所以可以采用二分查找的方法
27. //二分查找的时间复杂度为O(logn),排序的时间复杂度是O(nlogn),查找n次，总的时间复杂度为O(nlogn)，避免了空间的浪费
28. private static void execute2(int[] array, int m) {
29. for(int i = 0; i < array.length; i++) {
30. int tmp = m - array[i];
31. if (tmp > array[i]) {
32. if (binarySearch(array, tmp) != -1) {
33. System.out.println(array[i] + " " + tmp);
34. }
35. }
36. }
37. }
38. private static int binarySearch(int[] array, int key) {
39. if (array.length == 0) {
40. return -1;
41. }
42. int first = 0;
43. int last = array.length -1;
44. int mid;
45. while(first <= last) {
46. mid = (first + last) / 2;
47. if (array[mid] == key) {
48. return mid;
49. } else if (array[mid] < key) {
50. first = mid + 1;
51. } else {
52. last = mid -1;
53. }
54. }
55. return -1;
56. }
57. //思路：该方法的前提是要求数组是有序的，使用两个指针，分别指向最后一个元素和第一个元素，判断它们的和是否等于sum，若等于则打印，并且first向前移动，last也向前移动
58. //若它们的和小于sum，则说明first太小了，需要first向前移动，若它们的和大于sum，则说明last太大了，需要last向前移动，直到last>=first
59. private static void execute3(int[] array, int m) {
60. int first = 0;
61. int last = array.length -1;
62. int sum = 0;
63. while(first < last ) {
64. sum = array[first] + array[last];
65. if (sum == m) {
66. System.out.println(array[first] + " " + array[last]);
67. first++;
68. last--;
69. } else if (sum < m) {
70. first++;
71. } else {
72. last--;
73. }
74. }
75. }