解锁数组去重 9 种妙法，告别重复元素！

2023-10-01 04:06:53

引言

数组去重，顾名思义，就是从一个数组中移除重复元素，只保留唯一值。这在编程中是一个非常常见的操作，特别是在数据处理和数据分析领域。本文将介绍 9 种高阶方法来实现数组去重，涵盖 JavaScript、Python、Java 和 C++ 等多种语言。这些方法包括使用 Set 数据结构、filter() 方法、reduce() 方法、lodash 库、dict 数据结构等，并对每种方法的原理、时间复杂度和适用场景进行了详细讲解。无论是初学者还是资深开发者，都能从中找到适合自己的数组去重解决方案。

1. Set 数据结构

Set 数据结构是 JavaScript 和 Python 中内置的数据结构，它可以自动去除重复元素。使用 Set 数据结构去重非常简单，只需将数组元素逐个添加到 Set 中，然后将 Set 转换为数组即可。

const numbers = [1, 2, 3, 4, 5, 1, 2, 3];
const uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

numbers = [1, 2, 3, 4, 5, 1, 2, 3]
unique_numbers = list(set(numbers))
print(unique_numbers) # [1, 2, 3, 4, 5]

Set 数据结构的去重操作时间复杂度为 O(n)，其中 n 为数组的长度。

2. filter() 方法

filter() 方法是 JavaScript 和 Python 中的内置方法，它可以过滤数组中的元素，只保留满足特定条件的元素。我们可以使用 filter() 方法来过滤重复元素，具体做法是将数组中的每个元素与前面的元素比较，如果相同则过滤掉，否则保留。

const numbers = [1, 2, 3, 4, 5, 1, 2, 3];
const uniqueNumbers = numbers.filter((item, index) => numbers.indexOf(item) === index);
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

numbers = [1, 2, 3, 4, 5, 1, 2, 3]
unique_numbers = list(filter(lambda x: numbers.index(x) == numbers.count(x), numbers))
print(unique_numbers) # [1, 2, 3, 4, 5]

filter() 方法的去重操作时间复杂度为 O(n^2)，其中 n 为数组的长度。

3. reduce() 方法

reduce() 方法是 JavaScript 和 Python 中的内置方法，它可以将数组中的元素逐个累积，最终得到一个累积值。我们可以使用 reduce() 方法来实现数组去重，具体做法是将数组中的每个元素与累积值进行比较，如果相同则跳过，否则将该元素添加到累积值中。

const numbers = [1, 2, 3, 4, 5, 1, 2, 3];
const uniqueNumbers = numbers.reduce((acc, item) => {
  if (!acc.includes(item)) {
    acc.push(item);
  }
  return acc;
}, []);
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

numbers = [1, 2, 3, 4, 5, 1, 2, 3]
unique_numbers = list(reduce(lambda acc, item: acc if item in acc else acc + [item], numbers, []))
print(unique_numbers) # [1, 2, 3, 4, 5]

reduce() 方法的去重操作时间复杂度为 O(n^2)，其中 n 为数组的长度。

4. lodash 库

lodash 是一个 JavaScript 库，它提供了许多有用的函数来操作数组、对象等数据结构。我们可以使用 lodash 库的 _.uniq() 函数来实现数组去重，该函数可以自动去除数组中的重复元素。

const numbers = [1, 2, 3, 4, 5, 1, 2, 3];
const uniqueNumbers = _.uniq(numbers);
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

lodash 库的 _.uniq() 函数的去重操作时间复杂度为 O(n)，其中 n 为数组的长度。

5. dict 数据结构

dict 数据结构是 Python 中内置的数据结构，它是一个键值对集合。我们可以使用 dict 数据结构来实现数组去重，具体做法是将数组中的每个元素作为 dict 的键，然后将 dict 转换为列表即可。

numbers = [1, 2, 3, 4, 5, 1, 2, 3]
unique_numbers = list(dict.fromkeys(numbers))
print(unique_numbers) # [1, 2, 3, 4, 5]

dict 数据结构的去重操作时间复杂度为 O(n)，其中 n 为数组的长度。

6. 集合数据结构

集合数据结构是 Java 中内置的数据结构，它可以自动去除重复元素。我们可以使用集合数据结构来实现数组去重，具体做法是将数组元素逐个添加到集合中，然后将集合转换为数组即可。

int[] numbers = {1, 2, 3, 4, 5, 1, 2, 3};
Set<Integer> uniqueNumbers = new HashSet<>();
for (int number : numbers) {
  uniqueNumbers.add(number);
}
int[] result = uniqueNumbers.toArray(new int[0]);

集合数据结构的去重操作时间复杂度为 O(n)，其中 n 为数组的长度。

7. List 数据结构

List 数据结构是 Java 中内置的数据结构，它可以存储一组元素。我们可以使用 List 数据结构来实现数组去重，具体做法是将数组元素逐个添加到 List 中，然后使用 List 的去重方法去除重复元素即可。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3);
List<Integer> uniqueNumbers = numbers.stream().distinct().collect(Collectors.toList());

List 数据结构的去重操作时间复杂度为 O(n log n)，其中 n 为数组的长度。

8. Set 数据结构

Set 数据结构是 C++ 中内置的数据结构，它可以自动去除重复元素。我们可以使用 Set 数据结构来实现数组去重，具体做法是将数组元素逐个添加到 Set 中，然后将 Set 转换为数组即可。

int numbers[] = {1, 2, 3, 4, 5, 1, 2, 3};
set<int> uniqueNumbers;
for (int number : numbers) {
  uniqueNumbers.insert(number);
}
int result[uniqueNumbers.size()];
int i = 0;
for (int number : uniqueNumbers) {
  result[i++] = number;
}

Set 数据结构的去重操作时间复杂度为 O(n log n)，其中 n 为数组的长度。

9. Vector 数据结构

Vector 数据结构是 C++ 中内置的数据结构，它可以存储一组元素。我们可以使用 Vector 数据结构来实现数组去重，具体做法是将数组元素逐个添加到 Vector 中，然后使用 Vector 的去重方法去除重复元素即可。

vector<int> numbers = {1, 2, 3, 4, 5, 1, 2, 3};
vector<int> uniqueNumbers = vector<int>(numbers.begin(), numbers.end());
uniqueNumbers.erase(unique(uniqueNumbers.begin(), uniqueNumbers.end()), uniqueNumbers.end());