如何使用哈希图计算数字对的绝对差？

Question

我希望将整数数组转换为键值对，其中每个元素都是前一个元素的值和后一个元素的键（第一个和最后一个元素除外）。将数组转换为哈希图后，我需要计算数组中整数之间的差距。我能够转换数组，但正在寻找更优雅的解决方案，并且仍然需要找到间隙。public void calculateGap(int[] nums) {    int l = nums.length;    Map<Integer, Integer> dist = new HashMap<>();            for(int i=0; i<l; i++) {        if(i != l-1) {            int val = nums[i+1];            dist.put(nums[i], val);            }        if(i != 0) {            int key = nums[i-1];            dist.put(key, nums[i]);        }    }}输入：[3,6,9,1]作为哈希图输入：{3:6, 6:9, 9:1}输出：[3,3,8]

Answer 1

问：我想知道哈希图绕行的目的是什么，当人们可以直接计算距离时。

public int[] calculateGap(int[] nums) {

    if (nums.length < 2) {

        throw new IllegalArgumentException();

    }

    int[] dist = new int[nums.length - 1];

    for (int i = 1; i < nums.length; i++) {

        dist[i - 1] = Math.abs(nums[i] - nums[i - 1]);

    }

    return dist;

}

Answer 2

问：为什么不这样做：

public static Map<Integer, Integer> calculateGap(int[] nums) {

    Map<Integer, Integer> result = new HashMap<>();

    for(int i=0; i<nums.length - 1; i++) {

          result.put(nums[i], nums[i+1);    

    }

    return result;

}    

...

public static int gap ( Map<Integer, Integer> map, int idx) throws Exception {

  if (idx < 0 || idx >= map.size()) {

     throw new Exception ("index "+ idx " exceeds list bounds 0 .." + map.size() - 1);

  }

  return Math.abs(idx - map.get(idx);

}

Answer 3

没有必要使用哈希图。您可以完全跳过它，只需将计算出的间隙存储在 int[] 或 ArrayList 中：

//using int[]

public int[] calculateGap(int[] nums) {

    int len = nums.length;

    int [] dist = new int[len-1];

    for(int i = 1; i < len; i++) {

        dist[i-1] = Math.abs(nums[i] - nums[i-1]);

    }

}

//using ArrayList

public ArrayList<Integer> calculateGap(int[] nums) {

    int len = nums.length;

    ArrayList<Integer> dist = new ArrayList<Integer>();

    for(int i = 1; i < len; i++) {

        dist.add(Math.abs(nums[i] - num[i-1]));

    }

}

但是如果你绝对想使用 Hashmap，这就是你可以在单个循环中完成它的方法：

public static ArrayList<Integer> calculateGap(int[] nums) {

    int l = nums.length;

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

    ArrayList<Integer> gaps = new ArrayList<Integer>();

    int prev = 0;

    for(int i=1; i<l;i++) {

        prev = nums[i-1];

        dist.put(prev, nums[i]);

        gaps.add(Math.abs(dist.get(prev)-prev));

    } 

    return gaps;

}

或者使用 int[] 输出：

public static int[] calculateGap(int[] nums) {

    int l = nums.length;

    Map<Integer, Integer> dist = new HashMap<>();

    int[] gaps = new int[l-1];

    int prev = 0;

    for(int i=1; i<l;i++) {

        prev = nums[i-1];

        dist.put(prev, nums[i]);

        gaps[i-1] = (Math.abs(dist.get(prev)-prev));

    } 

    return gaps;

}

显然，您不必使用 dist.get(prev) 因为您可以只使用 nums[i]，但我假设由于某种原因您想使用 Hashmap 来获取间隙。

Answer 4

您可以执行此操作来填充 HashMap，因为它不需要特殊的边缘处理：

for(int i=1; i<l;i++)

{

    dist.put(nums[i-1], nums[1]);

} 

但是，如果您不想将其存储为哈希映射，则可以通过创建第二个名为 out put 的数组来对 dist 进行运行总计，然后执行以下操作：

for(int i=2; i < l; i++)

{

    output[i-2] = Math.abs(nums[i]-nums[i-1]);

}

仅对数组进行一次迭代，它返回与您的输出相同的输出