写一个冗余数据去重算法的代码? 用 C语言写

### 回答1：

#include <stdio.h>
int main(){
int arr[10], i, j, k, size;

printf("\nEnter size of array: ");
scanf("%d", &size);
printf("\nEnter %d elements in array: ", size);
for(i=0; i<size; i++){
scanf("%d", &arr[i]);
}
printf("\nThe array elements after removing redundancies are: ");
for(i=0; i<size; i++){
for(j=i+1; j<size; j++){
if(arr[i]==arr[j]){
for(k=j; k<size; k++){
arr[k]=arr[k+1];
}
size--;
j--;
}
}
}
for(i=0; i<size; i++){
printf("%d ", arr[i]);
}
return 0;
}

### 回答2：
以下是使用C语言编写的一个简单的冗余数据去重算法：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点
typedef struct Node {
    int value;
    struct Node* next;
} Node;

// 链表的插入操作
void insert(Node** head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->value = value;
    newNode->next = NULL;

    if (*head == NULL) {
        *head = newNode;
    } else {
        Node* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

// 链表的删除操作
void removeDuplicates(Node** head) {
    if (*head == NULL) {
        return;
    }
    Node* current = *head;
    while (current != NULL) {
        Node* runner = current;
        while (runner->next != NULL) {
            if (runner->next->value == current->value) {
                Node* duplicate = runner->next;
                runner->next = runner->next->next;
                free(duplicate);
            } else {
                runner = runner->next;
            }
        }
        current = current->next;
    }
}

// 遍历链表并打印结果
void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->value);
        temp = temp->next;
    }
    printf("\n");
}

int main() {
    Node* head = NULL;
    
    // 添加示例数据
    insert(&head, 5);
    insert(&head, 2);
    insert(&head, 3);
    insert(&head, 2);
    insert(&head, 1);
    insert(&head, 5);
    insert(&head, 4);

    printf("原始数据：");
    printList(head);

    printf("去重后的数据：");
    removeDuplicates(&head);
    printList(head);

    return 0;
}

该算法使用链表数据结构来存储数据，并使用两个嵌套的循环遍历链表，找到重复的数据节点并删除。最后，打印去重后的链表结果。

注意：上述代码只是一个简单的冗余数据去重示例，实际情况下根据具体需求可能需要更复杂的算法和数据结构。

### 回答3：
冗余数据去重算法可以通过使用哈希表来实现。以下是用 C 语言编写的代码：

#include <stdio.h>
#include <stdlib.h>

#define TABLE_SIZE 10000  // 哈希表的大小

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* hashTable[TABLE_SIZE];  // 哈希表

// 初始化哈希表
void initHashTable() {
    for (int i = 0; i < TABLE_SIZE; ++i) {
        hashTable[i] = NULL;
    }
}

// 哈希函数
int hash(int data) {
    return abs(data) % TABLE_SIZE;
}

// 查找元素
Node* search(int data) {
    int index = hash(data);
    Node* p = hashTable[index];
    while (p != NULL) {
        if (p->data == data) {
            return p;
        }
        p = p->next;
    }
    return NULL;
}

// 插入元素
void insert(int data) {
    int index = hash(data);
    if (search(data) != NULL) {
        return;
    }
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
}

// 冗余数据去重
void removeRedundancy(int* arr, int n) {
    initHashTable();
    for (int i = 0; i < n; ++i) {
        insert(arr[i]);
    }
    for (int i = 0; i < TABLE_SIZE; ++i) {
        Node* p = hashTable[i];
        while (p != NULL) {
            printf("%d ", p->data);
            p = p->next;
        }
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 1, 2, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    removeRedundancy(arr, n);
    return 0;
}

以上代码通过哈希表来存储数据，并查找和插入数据时根据哈希值来定位。通过遍历数组中的元素，将不重复的元素插入到哈希表中。最后，遍历哈希表并输出去重后的数据。运行以上代码，输出结果为`1 2 3 4 5`，去重成功。需要注意的是，由于哈希表的大小是有限的，可能会出现哈希冲突，但本例中的哈希函数采用取绝对值再取模的方式，相对较为简单，可以满足基本的去重需求。