1. 两数之和

1. 两数之和

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
// 定义哈希表节点结构体
typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

// 定义哈希表结构体
typedef struct {
    HashNode** table;
    int size;
} HashTable;

// 创建哈希表
HashTable* createHashTable(int size) {
    HashTable* hashTable = (HashTable*)malloc(sizeof(HashTable));
    hashTable->size = size;
    hashTable->table = (HashNode**)calloc(size, sizeof(HashNode*));
    return hashTable;
}

// 哈希函数
int hash(int key, int size) {
    return (key % size + size) % size;
}

// 插入键值对到哈希表
void insert(HashTable* hashTable, int key, int value) {
    int index = hash(key, hashTable->size);
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = hashTable->table[index];
    hashTable->table[index] = newNode;
}

// 在哈希表中查找键
int find(HashTable* hashTable, int key) {
    int index = hash(key, hashTable->size);
    HashNode* current = hashTable->table[index];
    while (current != NULL) {
        if (current->key == key) {
            return current->value;
        }
        current = current->next;
    }
    return -1;
}

// 释放哈希表
void freeHashTable(HashTable* hashTable) {
    for (int i = 0; i < hashTable->size; i++) {
        HashNode* current = hashTable->table[i];
        while (current != NULL) {
            HashNode* temp = current;
            current = current->next;
            free(temp);
        }
    }
    free(hashTable->table);
    free(hashTable);
}

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int* result = (int*)malloc(2 * sizeof(int));
    *returnSize = 2;
    HashTable* hashTable = createHashTable(numsSize);
    for (int i = 0; i < numsSize; i++) {
        int complement = target - nums[i];
        int index = find(hashTable, complement);
        if (index != -1) {
            result[0] = index;
            result[1] = i;
            freeHashTable(hashTable);
            return result;
        }
        insert(hashTable, nums[i], i);
    }
    freeHashTable(hashTable);
    return result;
}    

整体功能概述

此代码是为了在一个整数数组 nums 中找出两个数，使得它们的和等于给定的目标值 target，并且返回这两个数在数组中的下标。

代码详细解释

1. 哈希表相关结构体与函数

// 定义哈希表节点结构体
typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

// 定义哈希表结构体
typedef struct {
    HashNode** table;
    int size;
} HashTable;

• HashNode 结构体用于存储键值对。key 是数组中的元素值，value 是该元素在数组中的下标。next 指针用于处理哈希冲突，当多个键映射到同一个位置时，采用链表将它们连接起来。
• HashTable 结构体包含一个指向 HashNode 指针的数组 table，以及哈希表的大小 size。

// 创建哈希表
HashTable* createHashTable(int size) {
    HashTable* hashTable = (HashTable*)malloc(sizeof(HashTable));
    hashTable->size = size;
    hashTable->table = (HashNode**)calloc(size, sizeof(HashNode*));
    return hashTable;
}

• createHashTable 函数用于创建一个新的哈希表。它为 HashTable 结构体分配内存，设置哈希表的大小，并为 table 数组分配内存，初始时所有元素都被置为 NULL。

// 哈希函数
int hash(int key, int size) {
    return (key % size + size) % size;
}

• hash 函数是一个简单的哈希函数，它将键 key 映射到哈希表的一个索引位置。通过取模运算将键映射到 0 到 size - 1 的范围内。

// 插入键值对到哈希表
void insert(HashTable* hashTable, int key, int value) {
    int index = hash(key, hashTable->size);
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = hashTable->table[index];
    hashTable->table[index] = newNode;
}

• insert 函数将一个键值对插入到哈希表中。首先通过哈希函数计算键对应的索引，然后创建一个新的 HashNode 节点，将其插入到该索引位置的链表头部。

// 在哈希表中查找键
int find(HashTable* hashTable, int key) {
    int index = hash(key, hashTable->size);
    HashNode* current = hashTable->table[index];
    while (current != NULL) {
        if (current->key == key) {
            return current->value;
        }
        current = current->next;
    }
    return -1;
}

• find 函数在哈希表中查找给定的键。同样先通过哈希函数计算索引，然后遍历该索引位置的链表，查找是否存在匹配的键。如果找到则返回对应的值，否则返回 -1。

// 释放哈希表
void freeHashTable(HashTable* hashTable) {
    for (int i = 0; i < hashTable->size; i++) {
        HashNode* current = hashTable->table[i];
        while (current != NULL) {
            HashNode* temp = current;
            current = current->next;
            free(temp);
        }
    }
    free(hashTable->table);
    free(hashTable);
}

• freeHashTable 函数用于释放哈希表占用的内存。它遍历哈希表的每个索引位置，释放链表中的每个节点，然后释放 table 数组和 HashTable 结构体本身。

2. twoSum 函数

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int* result = (int*)malloc(2 * sizeof(int));
    *returnSize = 2;
    HashTable* hashTable = createHashTable(numsSize);
    for (int i = 0; i < numsSize; i++) {
        int complement = target - nums[i];
        int index = find(hashTable, complement);
        if (index != -1) {
            result[0] = index;
            result[1] = i;
            freeHashTable(hashTable);
            return result;
        }
        insert(hashTable, nums[i], i);
    }
    freeHashTable(hashTable);
    return result;
}

• 首先为结果数组 result 分配内存，returnSize 表示结果数组的长度为 2。
• 创建一个大小为 numsSize 的哈希表。
• 遍历数组 nums，对于每个元素 nums[i]，计算其补数 complement = target - nums[i]。
• 在哈希表中查找补数，如果找到则将对应的下标和当前下标存入结果数组，并释放哈希表，返回结果。
• 如果未找到补数，则将当前元素及其下标插入到哈希表中。
• 最后释放哈希表并返回结果数组。

哈希表、暴力枚举方法及其时间复杂度分析

1. 暴力枚举方法

def twoSum(nums, target):
    n = len(nums)
    for i in range(n):
        for j in range(i + 1, n):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

• 时间复杂度计算：外层循环遍历数组中的每个元素，需要 $n$ 次操作，其中 $n$ 是数组的长度。对于外层循环的每个元素，内层循环需要遍历其后面的所有元素，平均需要 $\frac{n-1}{2}$ 次操作。因此，总的操作次数为 $n\times \frac{n-1}{2}=\frac{n^2-n}{2}$。当 $n$ 很大时，忽略低阶项和常数系数，时间复杂度为 $O(n^2)$。

2. 哈希表方法

• 时间复杂度计算：哈希表方法只需要遍历数组一次，对于数组中的每个元素，查找和插入操作在平均情况下的时间复杂度都是 $O(1)$。因此，总的时间复杂度为 $O(n)$，其中 $n$ 是数组的长度。虽然在最坏情况下，哈希表的查找和插入操作可能会退化为 $O(n)$，但这种情况很少发生，平均情况下哈希表的性能是非常好的。

综上所述，暴力枚举方法的时间复杂度为 $O(n^2)$，哈希表方法的时间复杂度为 $O(n)$，哈希表方法在处理大规模数据时性能更优。