算法面试题之两数之和

从一个整型数组中查找两个数，这两个数之和需要等于指定的值
    如果无序的话，可以通过双重遍历、Map暂存法来实现
    如果是有序数组，还可通过 二分查找、双指针遍历法来实现

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * 从一个整型数组中查找两个数，这两个数之和需要等于指定的值
 * 如果无序的话，可以通过双重遍历、Map暂存法来实现
 * 如果是有序数组，还可通过 二分查找、双指针遍历法来实现
 */
public class FindSpecificNumbersTest {

    public static void main(String[] args) {
        int[] datas = {1,2,3,5,6,11,13,19};
        int target = 18;
        printArr(byIteration(datas,target));
        printArr(byMapStorage(datas,target));
        printArr(byBinarySearch(datas,target));
        printArr(byTwoPoints(datas,target));
    }

    public static void printArr(int[] datas){
        System.out.println(Arrays.toString(datas));
    }

    public static int[] byIteration(int[] datas, int target){
        for(int i=0,n=datas.length;i<n;i++){
            for(int j=i+1;j<n;j++){
                if(datas[i]+datas[j]==target){
                    return new int[]{i,j};
                }
            }
        }
        return new int[0];
    }

    public static int[] byMapStorage(int[] datas, int target){
        Map<Integer,Integer> indexMap = new HashMap<>(datas.length);
        for(int i=0,n=datas.length;i<n;i++){
            if(indexMap.containsKey(target-datas[i])){
                return new int[]{indexMap.get(target-datas[i]),i};
            }
            indexMap.put(datas[i],i);
        }
        return new int[0];
    }

    public static int[] byBinarySearch(int[] datas, int target){
        int lowIndex,maxIndex,midIndex;
        for(int i=0,n=datas.length;i<n;i++){
            lowIndex = i+1;
            maxIndex = n-1;
            while (lowIndex<maxIndex){
                midIndex = (lowIndex+maxIndex)/2;
                if(datas[i]+datas[midIndex]==target){
                    return new int[]{i,midIndex};
                }else if(datas[i]+datas[midIndex]>target){
                    maxIndex = midIndex-1;
                }else{
                    lowIndex = midIndex+1;
                }
            }
        }
        return new int[0];
    }

    public static int[] byTwoPoints(int[] datas, int target){
        int leftIndex = 0, rightIndex = datas.length-1;
        while (leftIndex<rightIndex){
            if(datas[leftIndex]+datas[rightIndex]==target){
                return new int[]{leftIndex,rightIndex};
            }else if(datas[leftIndex]+datas[rightIndex]>target){
                rightIndex--;
            }else {
                leftIndex++;
            }
        }
        return new int[0];
    }

}