c语言如何去掉数组中的重复元素

C语言去掉数组中的重复元素

核心观点：使用两个循环实现、利用哈希表去重、使用排序和双指针。其中，使用两个循环实现是一种较为直接和易于理解的方法。通过嵌套循环遍历数组中的每一个元素，并检查该元素是否已经在数组的前部分出现过。如果没有出现过，则将其保留，否则将其移除。虽然这种方法的时间复杂度较高，但它对于初学者来说是一个很好的练习。

一、使用两个循环实现

使用两个循环去除数组中的重复元素是一种最为基础和直观的方法。这个方法的核心思想是通过嵌套循环遍历数组，逐一检查每个元素是否已经出现过，如果出现过则跳过，否则保留。

1.1 步骤解析

外层循环：遍历数组中的每个元素。
内层循环：检查当前元素是否在其前面的部分中出现过。
移除重复元素：如果发现重复元素，则将其从数组中移除，并调整数组的长度。

1.2 代码示例

#include <stdio.h>
void removeDuplicates(int arr[], int *size) {
    int i, j, k;
    for (i = 0; i < *size; i++) {
        for (j = i + 1; j < *size;) {
            if (arr[i] == arr[j]) {
                // 移除重复元素
                for (k = j; k < *size - 1; k++) {
                    arr[k] = arr[k + 1];
                }
                (*size)--;
            } else {
                j++;
            }
        }
    }
}
int main() {
    int arr[] = {1, 2, 2, 3, 4, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int i;
    removeDuplicates(arr, &size);
    printf("Array after removing duplicates: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

二、利用哈希表去重

利用哈希表去重是一种更为高效的方法，尤其适用于大数据量的情况。哈希表的查找时间复杂度为O(1)，因此能够快速判断一个元素是否已经存在。

2.1 步骤解析

创建哈希表：用于记录已经遇到过的元素。
遍历数组：逐一检查每个元素是否在哈希表中出现过。
更新数组：如果元素未出现过，则将其保留并添加到哈希表中。

2.2 代码示例

#include <stdio.h>
#include <stdlib.h>
#define HASH_SIZE 1000
int hash(int key) {
    return abs(key) % HASH_SIZE;
}
void removeDuplicates(int arr[], int *size) {
    int hashTable[HASH_SIZE] = {0};
    int i, j = 0;
    for (i = 0; i < *size; i++) {
        int hashValue = hash(arr[i]);
        if (!hashTable[hashValue]) {
            hashTable[hashValue] = 1;
            arr[j++] = arr[i];
        }
    }
    *size = j;
}
int main() {
    int arr[] = {1, 2, 2, 3, 4, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int i;
    removeDuplicates(arr, &size);
    printf("Array after removing duplicates: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

三、使用排序和双指针

通过先对数组进行排序，然后使用双指针来移除重复元素，这种方法的时间复杂度为O(n log n)，适用于大部分情况。

3.1 步骤解析

排序数组：先对数组进行排序，使得重复元素相邻。
双指针扫描：使用两个指针，一个用于遍历数组，另一个用于记录新数组的位置。
更新数组：将不重复的元素移到新数组的位置。

3.2 代码示例

#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}
void removeDuplicates(int arr[], int *size) {
    if (*size == 0) return;
    qsort(arr, *size, sizeof(int), compare);
    int j = 0;
    for (int i = 1; i < *size; i++) {
        if (arr[i] != arr[j]) {
            j++;
            arr[j] = arr[i];
        }
    }
    *size = j + 1;
}
int main() {
    int arr[] = {1, 2, 2, 3, 4, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int i;
    removeDuplicates(arr, &size);
    printf("Array after removing duplicates: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

四、使用动态数组

动态数组是一种灵活且常用的数据结构，它可以根据需要动态调整大小。通过动态数组，可以方便地移除重复元素并调整数组大小。

4.1 步骤解析

初始化动态数组：创建一个空的动态数组。
遍历原数组：逐一检查每个元素是否已经存在于动态数组中。
更新动态数组：如果元素未出现过，则将其添加到动态数组中。

4.2 代码示例

#include <stdio.h>
#include <stdlib.h>
void removeDuplicates(int arr, int *size) {
    int *temp = (int *)malloc(*size * sizeof(int));
    int i, j = 0;
    for (i = 0; i < *size; i++) {
        int isDuplicate = 0;
        for (int k = 0; k < j; k++) {
            if ((*arr)[i] == temp[k]) {
                isDuplicate = 1;
                break;
            }
        }
        if (!isDuplicate) {
            temp[j++] = (*arr)[i];
        }
    }
    *arr = (int *)realloc(*arr, j * sizeof(int));
    for (i = 0; i < j; i++) {
        (*arr)[i] = temp[i];
    }
    *size = j;
    free(temp);
}
int main() {
    int *arr = (int *)malloc(7 * sizeof(int));
    arr[0] = 1; arr[1] = 2; arr[2] = 2; arr[3] = 3; arr[4] = 4; arr[5] = 4; arr[6] = 5;
    int size = 7;
    int i;
    removeDuplicates(&arr, &size);
    printf("Array after removing duplicates: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    free(arr);
    return 0;
}

五、使用标志数组去重

标志数组是一种简单且直观的去重方法，适用于元素范围已知且较小的情况。通过标志数组，可以快速判断一个元素是否已经出现过。

5.1 步骤解析

创建标志数组：用于记录每个元素是否已经出现过。
遍历原数组：检查每个元素是否已经在标志数组中标记。
更新原数组：将未出现过的元素保留，并更新标志数组。

5.2 代码示例

#include <stdio.h>
#include <stdlib.h>
#define MAX_VALUE 1000
void removeDuplicates(int arr[], int *size) {
    int flag[MAX_VALUE] = {0};
    int i, j = 0;
    for (i = 0; i < *size; i++) {
        if (!flag[arr[i]]) {
            flag[arr[i]] = 1;
            arr[j++] = arr[i];
        }
    }
    *size = j;
}
int main() {
    int arr[] = {1, 2, 2, 3, 4, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int i;
    removeDuplicates(arr, &size);
    printf("Array after removing duplicates: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

六、总结

在C语言中去掉数组中的重复元素有多种方法，每种方法都有其优缺点。使用两个循环实现是一种较为简单的方法，适合初学者；利用哈希表去重和使用排序和双指针则更加高效，适用于大数据量的情况；使用动态数组和标志数组则提供了更多的灵活性和简便性。

选择何种方法取决于具体的需求和应用场景。在实际编程中，理解这些方法的基本原理和适用情况，能够帮助开发者更好地选择和实现去重算法，提高代码的效率和可读性。