本文深入探讨了使用java嵌套循环查找数组中不重复元素的核心算法。通过详细解析外层循环迭代、内层循环比较以及关键条件if(i==j)的逻辑，揭示了该方法如何有效识别并打印数组中的每个首次出现的独特元素。文章还提供了代码示例和逐步执行分析，帮助读者全面理解其工作原理，并简要介绍了其他去重策略。
数组去重算法原理
在编程中，从数组中找出所有不重复的元素是一个常见需求。本文将聚焦于一种基于嵌套循环的直观方法，该方法通过比较当前元素与之前所有元素来判断其唯一性。
该算法的核心思想是：对于数组中的每一个元素 arr[i]，我们都检查它是否在 arr[0] 到 arr[i-1] 之间出现过。如果从未出现过，那么 arr[i] 就是一个不重复的元素，应该被记录下来。
核心逻辑解析
我们通过两个嵌套的 for 循环来实现这一逻辑：
外层循环 (for(int i=0; i<arr.length; i++))： 这个循环负责遍历数组中的每一个元素。变量 i 代表当前正在检查的元素的索引。
-
内层循环 (for(j=0; j<i; j++))： 对于外层循环选定的 arr[i]，内层循环的任务是检查 arr[i] 是否与它之前的所有元素 arr[0] 到 arr[i-1] 中的任何一个相等。
- 如果 arr[i] == arr[j] 成立，这意味着 arr[i] 在它之前已经出现过，因此它不是一个首次出现的独特元素。此时，我们使用 break 语句立即退出内层循环，因为我们已经知道 arr[i] 是重复的。
- 如果内层循环完整地执行完毕（即 j 从 0 递增到 i-1，并且没有找到任何匹配项），那么这意味着 arr[i] 在它之前从未出现过。
-
判断条件 (if(i==j))： 这是理解此算法的关键。
- 当内层循环因为找到重复元素而执行 break 时，j 的值会停留在找到匹配项时的索引，此时 j 必然小于 i。
- 当内层循环完整执行完毕，没有找到任何重复元素时，j 会一直递增到 i。具体来说，当 j 等于 i-1 时，循环体执行完，然后 j++ 使 j 变为 i，此时 j<i 的条件不再满足，内层循环终止。因此，在这种情况下，j 的值将等于 i。
所以，if(i==j) 这个条件就巧妙地成为了判断 arr[i] 是否为首次出现的独特元素的标志。如果 i==j，则 arr[i] 是独特的；否则，arr[i] 是重复的。
立即学习“Java免费学习笔记（深入）”；
代码示例
以下是实现上述逻辑的Java代码：
public class DistinctElement {
public static void main(String[] args) {
int [] arr = {10,10,20,30,10,20,40,30,60,100,10};
int count = 0; // 用于统计不重复元素的数量
System.out.print("不重复元素: ");
for(int i=0; i<arr.length; i++){
int j; // 注意 j 的声明在外层循环内部，确保每次外层循环开始时 j 重新开始计数
for(j=0; j<i; j++){ // 遍历 arr[0] 到 arr[i-1]
if(arr[i] == arr[j]) { // 如果 arr[i] 与之前的元素重复
break; // 退出内层循环
}
}
if(i==j) { // 如果内层循环没有提前中断，说明 arr[i] 是独特的
System.out.print(arr[i] + " ");
count++;
}
}
System.out.println("\n不重复元素总数: " + count);
}
}逐步解析
让我们使用示例数组 arr = {10, 10, 20, 30, 10, 20, 40, 30, 60, 100, 10} 来逐步跟踪代码执行：
-
i = 0 ( arr[0] = 10 )
- 内层循环 for(j=0; j<0; j++)：条件 j<i (即 0<0) 为假，内层循环不执行。
- 此时 j 的值仍为 0。
- 条件 if(i==j) (即 0==0) 为真。
- 打印 10，count 变为 1。
-
i = 1 ( arr[1] = 10 )
- 内层循环 for(j=0; j<1; j++)：
- j = 0：arr[1] (10) == arr[0] (10) 为真。
- 执行 break，内层循环终止。
- 此时 j 的值为 0。
- 条件 if(i==j) (即 1==0) 为假。
- 不打印任何内容。
- 内层循环 for(j=0; j<1; j++)：
-
i = 2 ( arr[2] = 20 )
- 内层循环 for(j=0; j<2; j++)：
- j = 0：arr[2] (20) == arr[0] (10) 为假。
- j = 1：arr[2] (20) == arr[1] (10) 为假。
- 内层循环条件 j<i (即 2<2) 为假，内层循环终止。
- 此时 j 的值为 2。
- 条件 if(i==j) (即 2==2) 为真。
- 打印 20，count 变为 2。
- 内层循环 for(j=0; j<2; j++)：
-
i = 3 ( arr[3] = 30 )
- 内层循环 for(j=0; j<3; j++)：
- j = 0：arr[3] (30) == arr[0] (10) 为假。
- j = 1：arr[3] (30) == arr[1] (10) 为假。
- j = 2：arr[3] (30) == arr[2] (20) 为假。
- 内层循环条件 j<i (即 3<3) 为假，内层循环终止。
- 此时 j 的值为 3。
- 条件 if(i==j) (即 3==3) 为真。
- 打印 30，count 变为 3。
- 内层循环 for(j=0; j<3; j++)：
-
i = 4 ( arr[4] = 10 )
- 内层循环 for(j=0; j<4; j++)：
- j = 0：arr[4] (10) == arr[0] (10) 为真。
- 执行 break，内层循环终止。
- 此时 j 的值为 0。
- 条件 if(i==j) (即 4==0) 为假。
- 不打印任何内容。
- 内层循环 for(j=0; j<4; j++)：
以此类推，程序将继续执行，最终输出： 不重复元素: 10 20 30 40 60 100不重复元素总数: 6
注意事项与替代方案
时间复杂度：这种嵌套循环的方法，对于长度为 N 的数组，其时间复杂度为 O(N^2)。当数组非常大时，性能会显著下降。
空间复杂度：此方法仅使用了常数级别的额外空间 (O(1))，因为它没有创建新的数据结构来存储中间结果。
-
替代方案：
-
使用 HashSet：Java 提供了 HashSet 这样的数据结构，它天然地不允许存储重复元素。将数组元素依次添加到 HashSet 中，最后 HashSet 中包含的就是所有不重复的元素。这种方法的时间复杂度通常为 O(N)，空间复杂度为 O(N)。
import java.util.HashSet; import java.util.Set;
public class DistinctElementHashSet { public static void main(String[] args) { int [] arr = {10,10,20,30,10,20,40,30,60,100,10}; Set
distinctElements = new HashSet<>(); for (int element : arr) { distinctElements.add(element); } System.out.println("不重复元素 (HashSet): " + distinctElements); System.out.println("不重复元素总数 (HashSet): " + distinctElements.size()); } } * **先排序再遍历**：可以先对数组进行排序（`O(N log N)`），然后遍历排序后的数组，相邻元素不相等时即为新发现的不重复元素。这种方法的时间复杂度为 `O(N log N)`，空间复杂度取决于排序算法（如果原地排序则为 `O(1)`，否则可能为 `O(N)`）。
-
使用 HashSet：Java 提供了 HashSet 这样的数据结构，它天然地不允许存储重复元素。将数组元素依次添加到 HashSet 中，最后 HashSet 中包含的就是所有不重复的元素。这种方法的时间复杂度通常为 O(N)，空间复杂度为 O(N)。
总结
通过本文的详细解析，我们深入理解了利用嵌套循环和 if(i==j) 条件来查找数组中不重复元素的工作原理。该方法虽然在处理大型数据集时效率不高，但其逻辑直观且不依赖额外的数据结构，对于理解基础算法和在特定场景下（如数组较小或内存受限）仍具有参考价值。在实际开发中，更推荐使用 HashSet 等集合类来高效地解决去重问题。
