*1 Two Sum two pointers(hashmap one scan)

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

incompleted solution: need to remember the index after sorting

class Solution {
    
    int bSearch(int[] nums, int left, int right, int comple){ // []
        while(right < nums.length && right >= left){
            int m = (right-left)/2 + left;
            if(nums[m] == comple) return m;
            if(nums[m] > comple) right = m-1;
            else if(nums[m] < comple) left = m+1;
        }
        return -1;
    }
    public int[] twoSum(int[] nums, int target) {
        //binary search
        int[] res = new int[2];
        Arrays.sort(nums);
        for(int i = 0; i<nums.length; i++){
            int complement = target - nums[i];
            //System.out.println(complement);
            int val = bSearch(nums, i+1, nums.length-1, complement);
            System.out.println(val);
            if(val!=-1){
                res[0] = i;res[1] = val;
                break;
            }
            
        }
        return res;
    }
}

-------------comparator and comparable

SOlution: hash map, one scan or two scans

<Integer, Integer>, store the array's value and index  <value, index>

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        Map<Integer, Integer> hashmap = new HashMap<>(); // number , index
        for(int i = 0; i<nums.length; i++){
            int comp = target - nums[i];
            if(hashmap.containsKey(comp)){
                res[0] = hashmap.get(comp); res[1] = i;
                break;
            }else {
                hashmap.put(nums[i],i);
            }
        }
        return res;
    }
}