1. PingCode智库首页
  2. 百科

c语言里如何存储映射

Edit1 • • 百科

c语言里如何存储映射

C语言里如何存储映射：使用数组、链表、哈希表等数据结构。 在实际编程中，C语言缺乏内置的高级数据结构，如映射（即键值对存储），但可以通过组合基本数据结构来实现映射功能。本文将详细探讨如何在C语言中存储映射，并介绍不同的方法和实现细节。

一、数组

1.1 使用结构体数组存储键值对

在C语言中，可以通过定义一个结构体来存储键值对，然后使用结构体数组实现映射。结构体数组的实现相对简单，适合小规模的数据存储。

#include <stdio.h>


#include <string.h>


#define MAX_SIZE 100


typedef struct {


    char key[50];


    int value;


} KeyValuePair;


KeyValuePair map[MAX_SIZE];


int size = 0;


void insert(char* key, int value) {


    strcpy(map[size].key, key);


    map[size].value = value;


    size++;


}


int search(char* key) {


    for (int i = 0; i < size; i++) {


        if (strcmp(map[i].key, key) == 0) {


            return map[i].value;


        }


    }


    return -1; // Key not found


}


int main() {


    insert("apple", 1);


    insert("banana", 2);


    printf("The value for 'apple' is: %dn", search("apple"));


    return 0;


}

1.2 优点和缺点

优点：

  • 简单易懂，易于实现。
  • 适合存储小规模的数据。

缺点：

  • 查找效率较低，为O(n)时间复杂度。
  • 不适合存储大规模数据，插入和查找速度会变慢。

二、链表

2.1 使用链表存储键值对

链表是一种动态数据结构，可以更灵活地存储数据。通过链表可以实现映射功能，并且插入和删除操作更加高效。

#include <stdio.h>


#include <stdlib.h>


#include <string.h>


typedef struct Node {


    char key[50];


    int value;


    struct Node* next;


} Node;


Node* head = NULL;


void insert(char* key, int value) {


    Node* newNode = (Node*)malloc(sizeof(Node));


    strcpy(newNode->key, key);


    newNode->value = value;


    newNode->next = head;


    head = newNode;


}


int search(char* key) {


    Node* current = head;


    while (current != NULL) {


        if (strcmp(current->key, key) == 0) {


            return current->value;


        }


        current = current->next;


    }


    return -1; // Key not found


}


int main() {


    insert("apple", 1);


    insert("banana", 2);


    printf("The value for 'apple' is: %dn", search("apple"));


    return 0;


}

2.2 优点和缺点

优点：

  • 动态分配内存，灵活性更高。
  • 插入和删除操作更高效。

缺点：

  • 查找效率仍为O(n)时间复杂度。
  • 需要额外的内存空间来存储指针。

三、哈希表

3.1 使用哈希表存储键值对

哈希表是一种通过哈希函数将键映射到特定位置的数据结构。哈希表的查找、插入和删除操作都非常高效，平均时间复杂度为O(1)。

#include <stdio.h>


#include <stdlib.h>


#include <string.h>


#define TABLE_SIZE 100


typedef struct Node {


    char key[50];


    int value;


    struct Node* next;


} Node;


Node* hashTable[TABLE_SIZE];


unsigned int hash(char* key) {


    unsigned int hashValue = 0;


    for (int i = 0; key[i] != ''; i++) {


        hashValue = (hashValue << 5) + key[i];


    }


    return hashValue % TABLE_SIZE;


}


void insert(char* key, int value) {


    unsigned int index = hash(key);


    Node* newNode = (Node*)malloc(sizeof(Node));


    strcpy(newNode->key, key);


    newNode->value = value;


    newNode->next = hashTable[index];


    hashTable[index] = newNode;


}


int search(char* key) {


    unsigned int index = hash(key);


    Node* current = hashTable[index];


    while (current != NULL) {


        if (strcmp(current->key, key) == 0) {


            return current->value;


        }


        current = current->next;


    }


    return -1; // Key not found


}


int main() {


    insert("apple", 1);


    insert("banana", 2);


    printf("The value for 'apple' is: %dn", search("apple"));


    return 0;


}

3.2 优点和缺点

优点：

  • 查找、插入和删除操作非常高效，平均时间复杂度为O(1)。
  • 适合存储大规模数据。

缺点：

  • 需要设计良好的哈希函数以避免冲突。
  • 处理冲突的方法（如链地址法）可能增加额外的时间和空间开销。

四、平衡二叉搜索树（BST）

4.1 使用平衡二叉搜索树存储键值对

平衡二叉搜索树（如AVL树或红黑树）是一种保证树高度平衡的二叉搜索树。它的查找、插入和删除操作的时间复杂度为O(log n)。

#include <stdio.h>


#include <stdlib.h>


#include <string.h>


typedef struct Node {


    char key[50];


    int value;


    struct Node* left;


    struct Node* right;


    int height;


} Node;


Node* createNode(char* key, int value) {


    Node* newNode = (Node*)malloc(sizeof(Node));


    strcpy(newNode->key, key);


    newNode->value = value;


    newNode->left = NULL;


    newNode->right = NULL;


    newNode->height = 1;


    return newNode;


}


int getHeight(Node* node) {


    if (node == NULL) return 0;


    return node->height;


}


int getBalance(Node* node) {


    if (node == NULL) return 0;


    return getHeight(node->left) - getHeight(node->right);


}


Node* rightRotate(Node* y) {


    Node* x = y->left;


    Node* T2 = x->right;


    x->right = y;


    y->left = T2;


    y->height = 1 + (getHeight(y->left) > getHeight(y->right) ? getHeight(y->left) : getHeight(y->right));


    x->height = 1 + (getHeight(x->left) > getHeight(x->right) ? getHeight(x->left) : getHeight(x->right));


    return x;


}


Node* leftRotate(Node* x) {


    Node* y = x->right;


    Node* T2 = y->left;


    y->left = x;


    x->right = T2;


    x->height = 1 + (getHeight(x->left) > getHeight(x->right) ? getHeight(x->left) : getHeight(x->right));


    y->height = 1 + (getHeight(y->left) > getHeight(y->right) ? getHeight(y->left) : getHeight(y->right));


    return y;


}


Node* insert(Node* node, char* key, int value) {


    if (node == NULL) return createNode(key, value);


    if (strcmp(key, node->key) < 0) node->left = insert(node->left, key, value);


    else if (strcmp(key, node->key) > 0) node->right = insert(node->right, key, value);


    else return node; // Duplicate keys are not allowed


    node->height = 1 + (getHeight(node->left) > getHeight(node->right) ? getHeight(node->left) : getHeight(node->right));


    int balance = getBalance(node);


    // Left Left Case


    if (balance > 1 && strcmp(key, node->left->key) < 0) return rightRotate(node);


    // Right Right Case


    if (balance < -1 && strcmp(key, node->right->key) > 0) return leftRotate(node);


    // Left Right Case


    if (balance > 1 && strcmp(key, node->left->key) > 0) {


        node->left = leftRotate(node->left);


        return rightRotate(node);


    }


    // Right Left Case


    if (balance < -1 && strcmp(key, node->right->key) < 0) {


        node->right = rightRotate(node->right);


        return leftRotate(node);


    }


    return node;


}


int search(Node* node, char* key) {


    if (node == NULL) return -1;


    if (strcmp(key, node->key) == 0) return node->value;


    if (strcmp(key, node->key) < 0) return search(node->left, key);


    return search(node->right, key);


}


int main() {


    Node* root = NULL;


    root = insert(root, "apple", 1);


    root = insert(root, "banana", 2);


    printf("The value for 'apple' is: %dn", search(root, "apple"));


    return 0;


}

4.2 优点和缺点

优点：

  • 查找、插入和删除操作的时间复杂度为O(log n)。
  • 树高度平衡，性能稳定。

缺点：

  • 实现复杂，代码量较大。
  • 需要额外的内存空间来存储节点的高度。

五、总结

在C语言中实现映射可以通过多种数据结构来实现，包括数组、链表、哈希表和平衡二叉搜索树等。每种方法都有其优点和缺点，选择合适的数据结构取决于具体的应用场景和需求。

数组适合小规模数据存储，简单易实现；链表适合动态数据存储，插入和删除操作高效；哈希表适合大规模数据存储，查找、插入和删除操作非常高效；平衡二叉搜索树查找、插入和删除操作的时间复杂度较优，但实现较复杂。

在实际开发中，推荐使用研发项目管理系统PingCode和通用项目管理软件Worktile来管理和优化项目进度，提高开发效率。

相关问答FAQs：

1. 什么是映射（Mapping）在C语言中的存储方式？
映射是指将一个值与另一个值关联起来的过程，C语言中常用的存储映射的方式有哪些？

2. 如何在C语言中实现映射的存储？
请问有哪些常用的数据结构可以用来存储映射关系？例如，数组、结构体、指针等。

3. 如何通过映射在C语言中实现字典（Dictionary）的存储？
请问有没有现成的库或者方法可以在C语言中实现类似字典的存储结构，方便快捷地进行键值对的操作和查找？

原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/1252879

赞 (0)
Edit1Edit1
上一篇 2024年8月31日 上午8:14
下一篇 2024年8月31日 上午8:14
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部