i = -1 在一段代码中的相关性

Question

我在研究一段代码时遇到了“i = -1”，我无法弄清楚它在场景中的意义。

代码的重点是对数组从小到大排序，求最大和最小数的差。

public int bigDiff(int[] nums) {
  int answer = 0;
  for (int i = 0; i < nums.length - 1; i++){
    if (nums[i] > nums[i + 1]){
      int temp = nums[i];
      nums[i] = nums[i + 1];
      nums[i + 1] = temp;
      i = -1;
    }
  }
  return (nums[nums.length - 1] - nums[0]);

}

提前致谢！

Answer 1

此构造用于实现作为参数传递的数组的“冒泡排序”。此代码的逻辑是使用您在示例中看到的每个“for”循环从头开始检查数组。当循环发现数组的下一个元素未排序时，它会将其按正确的顺序放置并从头开始检查数组。整个数组排序后退出循环。 x = - 1 - 此分配的目的是从索引 0 开始下一个循环（如您所见，在 x 的每个循环值递增 1 之后（'for' 循环中的 x++ 部分），所以下一个循环从索引 0 开始）

Answer 2

请注意，这整个函数并不是学习或模仿的好代码示例！

如果需要对数组进行排序的副作用，这里有一个完全等效的实现，它将在 O(n log n) 中运行：

public static int bigDiff(int[] nums) {
    Arrays.sort(nums);
    return nums[nums.length - 1] - nums[0];
}

如果不需要对数组进行排序的副作用，那么您可以返回O(n) 时间与O(1) 空格的差：

public static int bigDiff(int[] nums) {
    int highest = nums[0];
    int lowest = nums[0];
    for (int num : nums) {
        if (num > highest) {
            highest = num;
        }
        if (num < lowest) {
            lowest = num;
        }
    }
    return highest - lowest;
}

请注意，这些实现都不能处理错误情况：如果 nums 是 null，或者长度为零等会怎样？

Answer 3

本质上，这会找到 2 个无序的邻居并将它们交换。 然后它使用i=-1 重新启动循环，因为在循环结束时，i 将增加 1，从而得到i=0。

它从循环的开头重新开始，因为现在i-1 和i 也可能是错误的顺序。

这是目前为止最优化的解决方案，因为它的运行时间为 O(n^2)。

PS：由于很少有 cmets 调用这种冒泡排序，这是错误的。冒泡排序一直持续到数组的末尾，然后重新开始。

编辑： 这可以很容易地在 O(n) 时间内使用 O(1) 或常数空间通过查找数组中的最小值和最大值并返回差值来执行。

Answer 4

i=-1 用于从头开始重新启动 for 循环，以便再次遍历整个结构。请注意，i=-1 仅在算法找到无序内容时才会执行。

Answer 5

它重新开始循环。为什么？

因为您的排序算法（冒泡排序）会一一检查数字并交换它们。然后从第一个开始检查，直到所有数字都被排序。让我们看看例子：

我们的数字是：

25 36 37 25 60

如果我们没有那个 i=-1; 然后程序会检查 25 是否大于 36 no.So next Check , if 36 is greater than 37? No.所以接下来检查。如果 37 大于 25 ？是的，所以交换它们。现在我们有了：

25 36 25 37 60

如果 37 大于 60？否，完成。

但正如您所见，该数组未排序。每次交换数字时，您都应该重新检查并重新开始循环。

为什么是-1？你从 i=0; 开始循环在循环之后你有 i++。 i=-1 之后 i++ 表示 i=0；这意味着从头开始循环。

Answer 6

这是冒泡排序的一种实现。 i=-1; 如果发现某些内容未正确排序，则将循环重置为开头。它是 -1 而不是 0，因为 for 循环末尾的 i++ 在数组的开头将其迭代回 0。如果它不这样做，它只会通过一次，它可能会错过顺序错误的东西。在这里阅读：http://www.geeksforgeeks.org/bubble-sort/

冒泡排序看起来像这样（在这段代码中）：

第一遍：[0][3][3][1]第二遍3和1互换，迭代器 回到起点

第二遍：[0][3][1][3]前3和1互换

第三遍：[0][1][3][3] 什么都不需要做

如果它只通过一次，这是行不通的。因此，它会自行重置，以便再次通过。

（我应该注意，正如 cmets 中提到的，冒泡排序一开始效率低下，而且由于此实现在每次第一次出现问题时都会重置它，因此效率更低。）