一个含有多个元素的数组，有多种排序方式。它可以升序排列，可以降序排列，也可以像我们以前章节说过的，以波浪形方式排序，现在我们要看到的一种是绝对值排序。对于数组A,绝对值排序满足以下条件：|A[i]| < |A[j]|，只要i < j。例如下面的数组就是绝对值排序：

A:-49, 75, 103, -147, 164,-197,-238,314,348,-422

• 1

给定一个整数k，请你从数组中找出两个元素下标i,j，使得A[i]+A[j] == k。如果不存在这样的元素配对，你返回(-1,-1)。

对于这个题目，我们曾经讨论过当数组元素全是整数时的情况，要找到满足条件的配对(i,j)，我们让i从0开始，然后计算m = k - A[i]，接着在(i+1, n)这部分元素中，使用折半查找，看看有没有元素正好等于m，如果在(i+1,n)中存在下标j，满足A[j] == m 那么我们就可以直接返回配对(i,j)，这种做法在数组元素全是正数，全是负数，以及是绝对值排序时都成立，只是在绝对值排序的数组中，进行二分查找时，需要比对的是元素的绝对值。使用这种查找办法，算法的时间复杂度是O(n*lg(n))。

上面算法形式很紧凑，无论数组全是正数，负数，还是绝对值排序时，都有效。但我们还可以找到效率更高的算法，假设数组中的元素全是同一符号，也就是全是正数，或全是负数时，要找到A[i]+A[j] == k，我们可以这么做： 
1，让i = 0, j = n-1, 如果A[i] + A[j] == k 那么算法结束。 
2，如果A[i] + A[j] < k, 那么令 i = i +1; 
3，如果A[i] + A[j] > k, 那么令 j = j -1; 
上面步骤一直运行到i == j，或是A[i]+A[j] == k为止。这种做法的时间复杂度是O(n)。其算法效率比前面提到的方法要好，但问题在于，这种做法不能运用于绝对值排序的数组。为了能够应对绝对值排序的数组，我们需要对算法做一些改进。

对于满足A[i]+A[j] == k的元素，它必定满足下面三种情况之一： 
1，A[i]和A[j]都是正数。 
2，A[i]和A[j]都是负数。 
3，A[i]和A[j]是一正一负。 
对于前两种情况我们可以直接使用刚才使用的方法，对于第三种情况，我们需要做一个调整，对于第三种情况，我们让i指向最后一个整数，让j指向最后一个负数，如果A[i]+A[j] == k，那么算法结束，如果A[i]+A[j] > k, 那么让i指向下一个正数，如果A[i]+A[j] < k，那么让j指向下一个负数。

因此在查找满足条件的元素配对时，我们先看看前两种情况是否能查找到满足条件的元素，如果不行，那么我们再依据第三种情况去查找，无论是否存在满足条件的元素配对，我们算法的时间复杂度都是O(n)。我们看看相应的代码实现：

public class FindPairInAbsoluteSortedArray {private int[] sortedArray;private int indexI;private int indexJ;private boolean bSuccessed = false;private int k ;public FindPairInAbsoluteSortedArray(int[] sortedArray, int k) {this.sortedArray = sortedArray;this.indexI = -1;this.indexJ = -1;this.k = k;}private void findPairWithSameSign(boolean positive) {/** 如果满足条件的元素对都是正数或负数的话，那么用i指向第一个正数或负数，j指向最后一个整数或负数，* 如果两元素都是正数，如果A[i]+A[j] == k，算法结束，如果A[i] + A[j] > k, 那么j--；* 如果A[i]+A[j] < k，那么i++ * * 如果两元素都是负数，A[i] + A[j] == k 算法结束，如果A[i]+A[j]>k, 那么i++,直到下一个负数* 如果A[i]+A[j] < k ，那么j-- 直到下一个负数*/int i = 0, j = this.sortedArray.length - 1;if (positive == true) {while (this.sortedArray[i] < 0) {i++;}while (this.sortedArray[j] < 0) {j--;}} else {while (this.sortedArray[i] > 0) {i++;}while (this.sortedArray[j] > 0) {j--;}}do {if (this.sortedArray[i] + this.sortedArray[j] == this.k) {this.bSuccessed = true;this.indexI = i;this.indexJ = j;break;}if (this.sortedArray[i] + this.sortedArray[j] < this.k) {if (positive == true) {i++;while (i < this.sortedArray.length && this.sortedArray[i] < 0) {i++;}} else {j--;while (j > 0 && this.sortedArray[j] > 0) {j--;}}}else {if (positive == true) {j--;while (i < this.sortedArray.length && this.sortedArray[j] < 0) {j--;}} else {i++;while (i < this.sortedArray.length && this.sortedArray[i] > 0) {i++;}}}}while (i < j);}private void findPairWithDifferentSign() {/** 把i指向最后一个正数，把j指向最后一个负数，如果A[i] + A[j] == k, 算法结束* 如果A[i] + A[j] < k，那么j--;* 如果A[i] + A[j] > k , 那么k--*/int i = this.sortedArray.length-1;int j = this.sortedArray.length-1;while (this.sortedArray[i] < 0 && i > 0) {i--;}while (this.sortedArray[j] > 0 && j > 0) {j--;}do {if (this.sortedArray[i] + this.sortedArray[j] == this.k) {this.indexI = i;this.indexJ = j;this.bSuccessed = true;break;}if (this.sortedArray[i] + this.sortedArray[j] > k) {i--;while (i > 0 && this.sortedArray[i] < 0) {i--;}} else {j--;while (j > 0 && this.sortedArray[j] > 0) {j--;}}}while(i > 0 && j > 0);}public void findPair() {this.findPairWithSameSign(true);if (this.bSuccessed == false) {this.findPairWithSameSign(false);}if (this.bSuccessed == false) {this.findPairWithDifferentSign();}if (this.bSuccessed == false) {System.out.println("No such pair exist in  array");} else {System.out.println("The index are " + this.indexI + " and " + this.indexJ + " with value of " + this.sortedArray[this.indexI] + " and " + this.sortedArray[this.indexJ]);}}
}

类FindPairInAbsoluteSortedArray用于在绝对值排序的数组中查找满足条件的元素配对，它先根据两元素都是正数的情况下查找，然后再根据两元素都是负数的情况下查找，如果这两种情况都找不到，再尝试两元素一正一负的情况下查找，如果三种情况都找不到满足条件的元素，那么这样的元素在数组中不存在。

我们看看入口代码：

public class Searching {public static void main(String[] args) {int[] A = {-49, 75, 103, -147, 164, -197, -238, 314, 348, -422};int k = 167;FindPairInAbsoluteSortedArray fi = new FindPairInAbsoluteSortedArray(A, k);fi.findPair();}
}

上面代码运行结果如下： 

从运行结果上看，我们算法的实现是正确的，并且这种做法比原先依靠折半查找的效率要高，它的算法复杂度为O(n)，空间复杂度为O(1)。