//给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
//
//你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
//
//你可以按任意顺序返回答案。
//
//来源：力扣（LeetCode）
//链接：https://leetcode-cn.com/problems/two-sum

给定⼀个数组和⼀个⽬标和，从数组中找两个数字相加等于⽬标和，输出这两个数字的下标。学习笔记一：

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

public class Num001 {

//   给定⼀个数组和⼀个⽬标和，从数组中找两个数字相加等于⽬标和，输出这两个数字的下标。
   public  static int[] returnIndex(int[] nums1,int target){
       int result[] = new int[2];
       for(int i =0;i<nums1.length;i++){
           for(int j=i+1;j<nums1.length;j++){
               if(nums1[i]+nums1[j]==target){
                   result[0]=i;
                   result[1]=j;
                   return result;
               }
           }
       }
         return result;
   }

    public  static int[] returnIndex2(int[] nums1,int target){
       int[] result= new int[2];
        HashMap<Integer,Integer> maping = new HashMap<>();
       for (int i=0;i<nums1.length;i++){
//          先put会有问题: 重复元素put时，map中记录的永远是当前元素的 value，即：last 永远 ==i
           maping.put(nums1[i],i);
//           则  lat 永远 == i
           int last =maping.get(target-nums1[i]);
           if(maping.containsKey(target-nums1[i]) && last!=i){
               result[0] = i;
               result[1] = last;
               return result;
           }
       }
       return  result;
    }

    public  static int[] returnIndex3(int[] nums1,int target){
        int[] result= new int[2];
        HashMap<Integer,Integer> maping = new HashMap<>();
        for (int i=0;i<nums1.length;i++){
//          先put会有问题: 重复元素put时，map中记录的永远是当前元素的 value，即：last 永远 ==i
//            int last =maping.get(target-nums1[i]); //这样会报错空指针，因为首次maping还没有值，直接get就会空指针
//            maping.put(nums1[i],i);
//           则  lat 永远 == i
            if(maping.containsKey(target-nums1[i])){
                result[0] = i;
                result[1] = maping.get(target-nums1[i]);
                return result;
            }
            maping.put(nums1[i],i);
        }
        return  result;
    }

    public static int[] twoSum(int[] nums, int target){

        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
//            如果数组中有多个相同的数，则map记录的value将是最后一次出现的位置，如{3,3,3,3}，map对应的是<3,3>
            map.put(nums[i],i);
        }
        for(int i=0;i<nums.length;i++) {
            int sub = target - nums[i];
            if (map.containsKey(sub) && map.get(sub) != i) {
                return new int[]{i, map.get(sub)};
            }
        }
        throw new IllegalArgumentException("No two sum solution");
   }


    public static void main(String[] args) {
       int[] a = {3,3,3,3};
//       int[] result = twoSum(a, 6);
 int [] result = returnIndex3(a,6);
       System.out.println(result);

    }

}

 学习笔记二：

import java.util.HashMap;

public class Num001_1 {
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        for(int i=0;i<nums.length;i++){
//            if(nums[i]>target){
//                i++;
//            } 这里不对，因为不一定都是正数，直接去掉就可以
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    result[0]=i;
                    result[1]=j;
                }
            }
        }
        return result;
    }

    public int[] twoSum1(int[] nums, int target) {

        HashMap<Integer,Integer> aa = new HashMap<>();

        for(int i = 0 ;i < nums.length; i++){
            aa.put(nums[i],i); }
        for(Integer j: aa.keySet()){
            if(aa.containsKey(target-j))
                return new int[]{aa.get(j),aa.get(target-j)};
        }

        return new int[0];

    }
}