上午无意间看到微信群里有朋友在发算法面试题，我就看了看，中午吃完饭也思考了一下，做个总结。
题目
如上图所示，这位朋友面试的应该是一家不在北美之内的公司，哈哈。（return indices，indices是index的复数形式，盛行于除北美国家以外的英语里，而indexes在美国、加拿大等国的英语里）
Example:
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9;
return [0, 1].
之后填充：
class Solution{
public int[] twoSum(int[] nums, int target){
//TODO with Java
}
}
分析
一、遍历
最容易想到的一种解决方案，就是类似于选择排序那样，从左到右一点点慢慢缕，直到找到对应的那两个数为止，小编我自己实现了一把，如下：
//遍历的方式返回
int[] getSumSort(int[] arr, int sum,int n){
int i,j;
for(i = 0; i <n-1; i++){
for(j =i +1;j < n; j++){
if(arr[i] + arr[j] == sum){
return new int[]{i,j};
}
}
}
return new int[]{-1,-1};
}在Eclipse中跑了一遍：
public static void main(String[] args) {
int[] array = new int[]{7,1,4,10,12,21};
int length = array.length;
int[] result = new int[2];
SumEqualsTarget test = new SumEqualsTarget();
//遍历的方式
result = test.getSumSort(array,16,length);
System.out.println(Arrays.toString(result));
}显示结果：
这种写法确实是最low的一种写法，遍历的效率无疑是最低的，由于这种写法完全就是选择排序那套，参考各种排序的时间复杂度，如图：
可见，我这样子做完之后，时间复杂度为O(n^2)，比较消耗性能（性能很低很低），需要优化。
二、做差
1、思路：
这个想法是前几天晚上和Celine在路上交流的一个想法，题目和这个基本一直，当时我是想用tartget值和array中的数做差，得到一个int result，在排除掉被减数本身的数组中，看是否存在result这个值。即比如：
array[1, 3, 5, 7, 8, 9]；
target = 15;
用7做基准，result = target - 7 = 15 - 7 = 8; 相当于要在这个排除掉7的新数组中{1, 3, 5, 8, 9}，看是否有8的存在。
2.分析
我当时的这种想法， 首先选择基准的时候，需要遍历一次array数组，时间复杂度O（n），之后在剩余的数中进行查找，通过找网上的资料，对比如图：
可知，对于剩下的n-1个元素，如果进行查找"result"的值，比较简便的是“顺序查找”和“二分查找”，前者时间复杂度是O（n），后者是O（lgN），但是后者的前提是事先排序！！！
经过计算，如果最终采用“顺序查找”的方式来做，时间复杂度是O（n*n）即O（n^2），因为找基准被减数为O（n），查找也为O（n）。对于最终采用“二分查找”的方式，他的总时间复杂度则为O（n*lgN）,明显要比顺序查找小一些了，Pay Attention：如果使用“二分查找”，需要首先这个数组是有序的，那就提前先进行快排，那么如果我使用实现了一版代码，如下：
public static void main(String[] args) {
//定义原始数组、数组长度、两个数之和的目标值target
int[] array = new int[]{1,4,7,10,12,21}; //这里先进行快速排序，得到的数组名称为array（快排过程不予演示，时间复杂度O（n*lg2N））
int length = array.length;
int target = 14;
//做差的方式，内部基于二分查找
for(int i=0; i<length; i++){
int index;
int[] arrNew = ArrayUtils.remove(array, i); //ArrayUtils需要导入import org.apache.commons.lang3.*的包
int result1 = binarySearch(arrNew,target-array[i]);
if( result1 != -1){
index = ArrayUtils.indexOf(array, arrNew[result1]);
System.out.println("得到的下标值为：" + i +" , " + index);
}
}
}
//二分查找的方式
public static int binarySearch(int[] srcArray, int des){
int low = 0;
int high = srcArray.length-1;
while(low <= high) {
int middle = (low + high)/2;
if(des == srcArray[middle]) {
return middle;
}else if(des <srcArray[middle]) {
high = middle - 1;
}else {
low = middle + 1;
}
}
return -1;
} 由上可见，快速排序O（n*lgN），寻找基础O（n）,二分查找O（lgN），则这种方法的总的时间复杂度为O（n*lgN），要比遍历时O（n^2）小多了。虽然每次循环都需要实例化一个新的数组，但是一遍循环之后，该数组被释放，空间复杂度上并没有增加太多，非常可选的一个方案。
三、对做差法做封装
如上代码所示，我在main()方法中写了一些逻辑代码，其实这里仅仅需要调用一个方法就ok了，main中的有些职能是属于binarySearch()这个方法中的。即在设计模式中学过的“单一职责原则”， 同时结合题目，需要返回原数组的下标值，由于我先进行一趟排序，所以需要把原数组扔进去，在binarySearch()中查到的下标索引，需要转换为Array这个数组的下标索引，这样就Ok了！
这类的问题，有对排序、查询的基础了解，有了思路，实现就不难了。
That's all.
