LeetCode 刷题

// 构建 key 为字符串，value 为字符的哈希表
typedef struct {
    const char *key;
    char val;
    UT_hash_handle hh;
} HashItem;

// 迭代地释放所有哈希节点的空间
void hashFree(HashItem **obj) {
    HashItem *curr = NULL, *tmp = NULL;
    HASH_ITER(hh, *obj, curr, tmp) {
        HASH_DEL(*obj, curr);  
        free(curr);
    }
}

#define MAX_LEN (7)  // strlen("⁄")

char *entityParser(char* text) {
    const char *entities[] = {""", "'", "&", ">", "<", "⁄", NULL};
    char entitiesVal[] = {'\"', '\'', '&', '>', '<', '/'};
    HashItem *hashTbl = NULL, *hashNode = NULL;

    for (int i = 0; entities[i]; i++) {
        hashNode = (HashItem *)malloc(sizeof(HashItem));
        hashNode->key = entities[i];
        hashNode->val = entitiesVal[i];
        // 已知添加的 key 不会重复，这里就不在添加前先查找 key 是否存在了
        HASH_ADD_STR(hashTbl, key, hashNode);
    }

    int n = strlen(text), ;
    char *ans = (char *)malloc((n + 1) * sizeof(char));

    int idx = 0, i = 0;
    while (text[i] != '\0') {
        if (text[i] != '&') { // 不是字符实体首字符
            ans[idx++] = text[i++];
        } else {  // 是字符实体首字符
            hashNode = NULL;
            char temp[8] = {'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'};

            // 遍历接下可能出现字符实体的一段字符串
            for (int j = i; j < fmin(i + MAX_LEN, n); j++) {
                temp[j - i] = text[j];
                HASH_FIND_STR(hashTbl, temp, hashNode);
                if (hashNode) { // 找到则替换，指针后移特定长度
                    ans[idx++] = hashNode->val;
                    i = j + 1;
                    break;
                }
            }
            if (!hashNode) { // 遍历完也没找到
                ans[idx++] = text[i++];
            }
        }
    }

    ans[idx] = '\0';
    hashFree(&hashTbl);

    return ans;
}

typedef struct _entityChar {
    char *entity;
    char character;
} EntityChar;

EntityChar entityList[] = {
    {""", '\"'},
    {"'", '\''},
    {"&", '&'},
    {">", '>'},
    {"&lt;", '<'},
    {"&frasl;", '/'},
};

char *entityParser(char *text) {
    int n = strlen(text);
    int cnt = sizeof(entityList) / sizeof(entityList[0]);  // 字符实体的个数

    char *ans = (char *)malloc((n + 1) * sizeof(char));
    char *p = ans;  // 使用指针的方式填充结果

    for (int i = 0; i < n; ) {
        bool isEntity = false;
        if (text[i] == '&') {
            for (int j = 0; j < cnt; j++) {
                char *pKey = entityList[j].entity;
                char *pVal = &entityList[j].character;
                if (strncmp(text + i, pKey, strlen(pKey)) == 0) {
                    strcpy(p, pVal);  // 这样写可以兼容值是字符串的情况
                    p += strlen(pVal);
                    i += strlen(pKey);
                    isEntity = true;
                    break;
                }
            }
        }
        if (!isEntity) {
            *(p++) = text[i++];
        }
    }
    *p = '\0';
    return ans;
}