干tm的算法1:两数之和

题目

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

对应参入为 一个数组 nums[2, 7, 11, 15] ,跟一个 target 9 。要求返回值是 一个二个数组[0,1]
假设都会有一个答案，那么思考是如何思考，首先是对应的循环。我手里拿着外圈的 2 也就是num[0] ，然后 然后算出对应值为 9 - num[0] = 7,接着循环寻找对应 num[?] = 7,匹配上就带上，对应值都放到一个新的numsResult[2] 中返回前端显示。

 // // 双重循环 循环极限为(n^2-n)/2 
        for(int i = 0; i < nums.length; i++){
            for(int j = nums.length - 1; j > i; j --){
                if(nums[i]+nums[j] == target){
                   indexs[0] = i;
                   indexs[1] = j; 
                   return indexs;
                }
            }
        }

多少是上面的关键代码。但是有缺陷，而且不小。因为首先你一个首开始循环，另一个尾开始循环的话，基于数组是连续，并且从小到大排序，才有这样比较好的效果，因为里面是 j > i
那么进行优化

  for(int i = 0; i < nums.length; i++){ //对应外圈从0开始，那么对应内圈到0
  //结束,匹配不上是一种双向否定，所以j>i 是正确的
            for(int j = nums.length - 1; j > 0; j --){
                if(nums[i]+nums[j] == target){
                   indexs[0] = i;
                   indexs[1] = j; 
                   return indexs;
                }
            }
        }

外面循环一个个递增，里面循环也是一个个递减。 （其实这里后续理解偏差了，因为一开始的时候当外圈从0开始时候，内圈循环也是到0结束，所以第一种的那种j>i 是一种正确的思路）

那么比较好的是什么。算法就是看是否能从循环去完成，变成数字次数进行查询，也就是复杂度是一个数字，而不是什么有参数介入，导致会调用很多次，内外循环直接就是平方了。

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

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] indexs = new int[2];
        
        // 建立k-v ，一一对应的哈希表
        HashMap<Integer,Integer> hash = new HashMap<Integer,Integer>();
        for(int i = 0; i < nums.length; i++){
            if(hash.containsKey(nums[i])){
                indexs[1] = i;
                indexs[0] = hash.get(nums[i]);
                return indexs;
            }
            // 将数据存入 key为补数 ，value为下标
            hash.put(target-nums[i],i);
        }
        // // 双重循环 循环极限为(n^2-n)/2 
        // for(int i = 0; i < nums.length; i++){
        //     for(int j = nums.length - 1; j > 0; j --){
        //         if(nums[i]+nums[j] == target){
        //            indexs[0] = i;
        //            indexs[1] = j; 
        //            return indexs;
        //         }
        //     }
        // }
        return indexs;
    }
}

比较好的一种思路，利用的是 hashmap的特性，就是根据对应key是直接命中，但是这个小小的失败。就是 如果对应数据是 【2,3，3,5】 然后target 8 。这样的话会有返回值 [1,3],[2,3]
这里返回值会是2,3 而不是 1,3

那么如何通用性。
依然是利用 hashMap
不过可以是

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

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] indexs = new int[2];
        
        // 建立k-v ，一一对应的哈希表  数据进行处理
        HashMap<Integer,String> hash = new HashMap<Integer,String>();
        for(Integer i = 0; i < nums.length; i++){

            if(hash.containsKey(nums[i])){
                hash.put(nums[i],hash.get(nums[i])+","+i.toString);
            }else{
                hash.put(nums[i],i.toString); 
            }
            if(hash.get(target - nums[i])!=null){
                String[] num = hash.get(target - nums[i]).split(",");
                indexs[0] = num[0].Integer;
                indexs[1] = i;
                return indexs;
            }
        }
        return indexs;
    }
}

上面代码没有经过测试，大致是一个思路，具体跑起来放后面去。我大概思路是，对传入的哪个数组进行放到hashmap中进行存储起来，对应数组值为key，然后数字的下标，组成对应的string，用，拼接。这样的数据就普遍性高很多。后续是进行一次判断，也就是对应值以当前为基准，判断相减之后的差是否在这个hashmap内，如果在，那么数据就完成了。不过未校对自身是否不符合。可以添加

 indexs[0] = num[0].Integer;
 indexs[1] = i;
  需要      num[0].Integer !=   i      

大致这样的。如果获取全部方法就循环放置完毕，最后都保存到集合中，再对集合进行分析处理。获取全部数据。

2020-12-17 补充：上面多少有些许潦草。应该要判断对应map的value是否有且只有一个。简单的来弄就判断value是否有，号，如果存在多个，用逗号分隔，那么就认为是存在对应数据，上面仅判断了第一个，未判断是否存在多个，考虑有些许欠缺。

数据当深挖，才有乐趣。

---

漫漫长路，一个小周跟他一个小陈朋友一起努力奔跑。

---