utHash.h接口学习实例

最新推荐文章于 2024-08-16 08:00:00 发布
最新推荐文章于 2024-08-16 08:00:00 发布
阅读量1k 收藏
点赞数
分类专栏： 编程工具
原文链接：https://blog.csdn.net/qq_23091073/article/details/86485095
版权

typedef struct ChainNode {
    struct ChainNode *next;
    char *data; // 文件路径 + 文件名
}ChainNode;

typedef struct Chain {
    struct ChainNode *head;
    int count;
}Chain;

#define MAX_CONTEXT_LEN  50

typedef struct Hash {
    char key[MAX_CONTEXT_LEN + 2];
    Chain chain;
    UT_hash_handle hh;
}Hash;

Hash *strHash = NULL;

void AddChainNode(char* data, Chain *chain)
{
    ChainNode *node = (ChainNode*) malloc(sizeof(ChainNode));
    node->next = 0;
    node->data = (char*)malloc(sizeof(char) * (strlen(data) + 1));
    strcpy(node->data, data);

    chain->count++;
    if (chain->head == 0) {
        chain->head = node;
    } else {
        node->next = chain->head;
        chain->head = node;
    }
    return;
}

void AddHashNode(char *key, char* data)
{
    Hash *hashNode;
    HASH_FIND_STR(strHash, key, hashNode);
    if (hashNode == 0) {
        hashNode = (Hash*)malloc(sizeof(Hash));
        strcpy(hashNode->key, key);
        hashNode->chain.count = 0;
        hashNode->chain.head = 0;
        AddChainNode(data, &hashNode->chain);
        HASH_ADD_STR(strHash, key, hashNode);
    } else {
        AddChainNode(data, &hashNode->chain);
    }
    return;
}

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
#define MAX_PATH_LENGTH  10000
#define MAX_CONTEXT_LEN  50

int GetPath(char *path, char *pathBuffer)
{
    int pos;
    for (pos = 0; pos < strlen(path); pos++) {
        if (path[pos] == ' ') {
            break;
        }
        pathBuffer[pos] = path[pos];
    }
    pathBuffer[pos++] = '/';
    return pos;
}

void FileProc(int pathLen, char *pathBuffer, char *path)
{
    int count = pathLen;
    char context[MAX_CONTEXT_LEN + 2];
    // root/a 1.txt(abcd) 2.txt(efgh)
    //pathBuffer[count++] = '/';
    for (int i = pathLen; i < strlen(path); i++) {
        if (path[i] == '(') {
            pathBuffer[count++] = 0; // 路径 + 文件名
            int contextLen = 0;
            while (path[++i] != ')') {
                context[contextLen++] = path[i];
            }
            context[contextLen++] = 0; // 文件内容
            // 文件内容已经取出， 插入hash
            AddHashNode(context, pathBuffer);
            // 插入完成后，回退count到只包含路径， 此时i停留在 ), 过滤掉空格
            i++;
            count = pathLen;
            continue;
        } else {
            pathBuffer[count++] = path[i];
        }
    }
}

void DestroyHashNode(Hash *node)
{
    Chain chain = node->chain;
    ChainNode *head, *temp;
    head = chain.head;

    while(head) {
        temp = head->next;
        free(head->data);
        free(head);
        head = temp;
    }
    free(node);
    return;
}

char ***Output(int *retuenSize, int **returnColSize)
{
    int count = 0;
    Hash *current_user, *tmp;
    HASH_ITER(hh, strHash, current_user, tmp) {
        if (current_user->chain.count > 1) {
            count++;
        } else {
            HASH_DEL(strHash, current_user);  /* delete; users advances to next */
            DestroyHashNode(current_user);            /* optional- if you want to free  */
        }
    }
    *retuenSize = count;
    char *** output = (char***)malloc(sizeof(char**) * count);
    int *retCol = (int *)malloc(sizeof(int) * count);
    *returnColSize = retCol;

    count = 0;
    ChainNode *head;
    HASH_ITER(hh, strHash, current_user, tmp) {
        if (current_user->chain.count > 1) {
            output[count] = (char**)malloc(sizeof(char*) * (current_user->chain.count));
            head = current_user->chain.head;
            int fileNUm = 0;
            while (head) {
                output[count][fileNUm] = (char*)malloc(sizeof(char) * (strlen(head->data) + 1));
                strcpy(output[count][fileNUm], head->data);
                fileNUm++;
                head = head->next;
            }
            retCol[count] = current_user->chain.count;
            count++;
            HASH_DEL(strHash, current_user);
            DestroyHashNode(current_user);
        }
    }
    strHash = NULL;
    return output;
}

char *** findDuplicate(char ** paths, int pathsSize, int* returnSize, int** returnColumnSizes){
    char pathBuffer[MAX_PATH_LENGTH];
    int pathLen;
    int pathLoop;

    // 便利每一行输入，取出文件路径path
    for (pathLoop = 0; pathLoop < pathsSize; pathLoop++) {
        // root/a 1.txt(abcd) 2.txt(efgh)
        pathLen = GetPath(paths[pathLoop], pathBuffer); // 记录文件路径长度， 存储在0 至 count - 1
        FileProc(pathLen, pathBuffer, paths[pathLoop]);
    }

    // 遍历所有的hash节点，data个数超过1的进行输
    return Output(returnSize, returnColumnSizes);
}

 

https://blog.csdn.net/qq_23091073/article/details/86485095

 

uthash使用
初始化
uthash需要用户定义自己的数据结构，一个包含UT_hash_handle hh的结构体
还需要定义键和值(可选)，这里将id作为key, name作为value
struct my_struct {
    int id;                    /* key */
    char name[10];
    UT_hash_handle hh;         /* makes this structure hashable */
};
typedef struct my_struct HashNode;
typedef struct my_struct *HashHead;

1
2
3
4
5
6
7
8
添加
向hashtable中添加数据
key是int，可以使用 HASH_ADD_INT
key是字符串，可以使用 HASH_ADD_STR
key是指针,可以使用 HASH_ADD_PTR
其它，可以使用 HASH_ADD，上述实际都是调用这个方法，不过简化了参数
    void hashTabel_add(HashHead *head, HashNode *users) {
        // id是key的属性名字，虽然很奇怪，实际作为宏参数会被替换掉
        // 可以看下面源码，intfield会替换换成&((add)->fieldname)
        if(!find_user(*head, users->id))
            HASH_ADD_INT(*head, id, users);
    }
1
2
3
4
5
6
#define HASH_ADD_INT(head,intfield,add)                                          \
    HASH_ADD(hh,head,intfield,sizeof(int),add)
#define HASH_ADD(hh,head,fieldname,keylen_in,add)                                \
  HASH_ADD_KEYPTR(hh, head, &((add)->fieldname), keylen_in, add)
1
2
3
4
替换
与添加差不多，会在添加前，删除key相同的节点，再添加新的节点
如果key是int，可以使用 HASH_REPLACE_INT
void replace_user(HashHead *head, HashNode *newNode) {
    HashNode *oldNode = find_user(*head, newNode->id);
    if (oldNode)
        HASH_REPLACE_INT(*head, id, newNode, oldNode);
}
1
2
3
4
5
查找
根据key查找节点
如果key是int，可以使用 HASH_FIND_INT
HashNode *find_user(HashHead head, int user_id) {
    HashNode *s;
    HASH_FIND_INT(head, &user_id, s);  /* s: output pointer */
    return s;
}
1
2
3
4
5
删除
删除节点
使用 HASH_DEL
void delete_user(HashHead *head,HashNode *user) {
    if (user) {
        HASH_DEL(*head, user);  /* user: pointer to deletee */
        free(user);             /* optional; it's up to you! */
    }
}
1
2
3
4
5
6
计数
统计节点数
使用 HASH_COUNT
int count_user(HashHead head) {
    return HASH_COUNT(head);
}
1
2
3
遍历
遍历节点
可以用循环或者使用 HASH_ITER
void print_user(HashHead head) {
    HashNode *s;
    printf("size is %d\n", count_user(head));
    for (s = head; s != NULL; s = s->hh.next) {
        printf("user id %d, name %s\n", s->id, s->name);
    }
}
void print_user_iterator(HashHead head) {
    HashNode *s, *tmp;
    printf("size is %d\n", count_user(head));
    HASH_ITER(hh, head, s, tmp) {
        printf("user id %d: name %s\n", s->id, s->name);
        /* ... it is safe to delete and free s here */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
排序
给节点排序，可以根据key或者value
使用 HASH_SORT
int name_sort(HashNode *a, HashNode *b) {
    return strcmp(a->name,b->name);
}

int id_sort(HashNode *a, HashNode *b) {
    return (a->id - b->id);
}

void sort_by_name(HashHead *head) {
    HASH_SORT(*head, name_sort);
}

void sort_by_id(HashHead *head) {
    HASH_SORT(*head, id_sort);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
三、完整代码
#include <stdio.h>
#include <stdlib.h>
#include "uthash.h"

typedef struct my_struct {
    int id;            /* we'll use this field as the key */
    char name[10];
    UT_hash_handle hh; /* makes this structure hashable */
}HashNode;
typedef HashNode* HashHead;

int count_user(HashHead head);
HashNode *find_user(HashHead head, int user_id) {
    HashNode *s;
    HASH_FIND_INT(head, &user_id, s);  /* s: output pointer */
    return s;
}
void add_user(HashHead *head, HashNode *users) {
    if(!find_user(*head, users->id))
        HASH_ADD_INT(*head, id, users);
}
void replace_user(HashHead *head, HashNode *newNode) {
    HashNode *oldNode = find_user(*head, newNode->id);
    if (oldNode)
        HASH_REPLACE_INT(*head, id, newNode, oldNode);
}
void delete_user(HashHead *head,HashNode *user) {
    if (user) {
        HASH_DEL(*head, user);  /* user: pointer to deletee */
        free(user);             /* optional; it's up to you! */
    }
}
void print_user(HashHead head) {
    HashNode *s;
    printf("size is %d\n", count_user(head));
    for (s = head; s != NULL; s = s->hh.next) {
        printf("user id %d, name %s\n", s->id, s->name);
    }
}
void print_user_iterator(HashHead head) {
    HashNode *s, *tmp;
    printf("size is %d\n", count_user(head));
    HASH_ITER(hh, head, s, tmp) {
        printf("user id %d: name %s\n", s->id, s->name);
        /* ... it is safe to delete and free s here */
    }
}
int count_user(HashHead head) {
    return HASH_COUNT(head);
}
int name_sort(HashNode *a, HashNode *b) {
       return strcmp(a->name,b->name);
}

int id_sort(HashNode *a, HashNode *b) {
       return (a->id - b->id);
}

void sort_by_name(HashHead *head) {
       HASH_SORT(*head, name_sort);
}

void sort_by_id(HashHead *head) {
       HASH_SORT(*head, id_sort);
}
int main()
{
    printf("--------------init---------------\n");
    HashHead head = NULL;
    printf("--------------add---------------\n");
    HashNode *node = malloc(sizeof(HashNode));
    node->id = 1;
    strcpy(node->name, "tom");
    add_user(&head, node);

    node = malloc(sizeof(HashNode));
    node->id = 2;
    strcpy(node->name, "jerry");
    add_user(&head, node);

    node = malloc(sizeof(HashNode));
    node->id = 3;
    strcpy(node->name, "jack");
    add_user(&head, node);

    node = malloc(sizeof(HashNode));
    node->id = 0;
    strcpy(node->name, "zero");
    add_user(&head, node);

    print_user(head);

    printf("--------------replace---------------\n");
    HashNode *newNode = malloc(sizeof(HashNode));
    newNode->id = 3;
    strcpy(newNode->name, "rose");
    replace_user(&head, newNode);
    print_user(head);

    printf("--------------delete---------------\n");
    delete_user(&head, find_user(head, 1));
    print_user(head);
    printf("--------------sort-by-id---------------\n");
    sort_by_id(&head);
    print_user(head);
    printf("--------------sort-by-name---------------\n");
    sort_by_name(&head);
    print_user(head);
    return 0;
}
————————————————
版权声明：本文为CSDN博主「aabond」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_23091073/article/details/86485095

s651665496
关注
专栏目录
uthash源码
03-22
很好用的uthash源码。
开源库uthash第一弹uthash.h
小银子
04-05 1万+
一、简介 1.1 uthash介绍 uthash是C的比较优秀的开源代码，它实现了常见的hash操作函数，例如查找、插入、删除等待。该套开源代码采用宏的方式实现hash函数的相关功能，支持C语言的任意数据结构最为key值，甚至可以采用多个值作为key，无论是自定义的struct还是基本数据类型，需要注意的是不同类型的key其操作接口方式略有不通。官方原文说明如下： Any C structur...
c语言开源库之uthash用法
最新发布
hutaotaotao的博客
08-16 1045
c语言开源库之uthash用法、以及注意事项
C 语言哈希表使用——uthash.h
weixin_50589485的博客
01-02 1089
C语言哈希表的使用；数据结构
uthash使用示例
yuyuyuliang00的博客
03-16 343
uthash中使用不同类型的键的程序示例
哈希表uthash
起风的博客
12-23 427
C语言哈希表库uthash的使用
OAuth认证协议中的HMACSHA1加密算法(实例)
12-19
HMAC（Hash-based Message Authentication Code）是一种基于消息摘要的认证码，它通过结合密钥和哈希函数来生成一个固定长度的摘要，用于验证数据的完整性和来源。HMAC-SHA1是使用SHA1哈希函数的HMAC实现，提供了一...
第四周学习笔记总结(类相关)
weixin_61215132的博客
11-20 1406
类的相关笔记
深入理解Spark ML：基于ALS矩阵分解的协同过滤算法与源码分析
热门推荐
06-26 3万+
http://blog.csdn.net/u011239443/article/details/51752904随着互联网的迅猛发展,为了满足人们在繁多的信息中获取自己需要内容的需求,个性化推荐应用而生。协同过滤推荐是其中运用最为成功的技术之一。其中,基于用户的最近邻法根据相似用户的评分来预测当前用户的评分。然而,在用户数量以及用户评分不足的情况下,该方法存在冷启动和数据稀疏的问题。为了解决这两个问题，业界提出了提出了基于项的最近邻法，利用项之间相似性稳定的特点可以离线计算相似性,降低了在线计算量,提高了推
机器学习(Machine Learning)&深度学习(Deep Learning)资料
weixin_30756499的博客
07-07 1万+
##机器学习(Machine Learning)&深度学习(Deep Learning)资料(Chapter 1)---#####注:机器学习资料[篇目一](https://github.com/ty4z2008/Qix/blob/master/dl.md)共500条,[篇目二](https://github.com/ty4z2008/Qix/blob/master/dl2.md)开始更新...
机器学习(Machine Learning)与深度学习(Deep Learning)资料汇总
ZhangPY的专栏
02-28 6686
《Brief History of Machine Learning》 介绍:这是一篇介绍机器学习历史的文章，介绍很全面，从感知机、神经网络、决策树、SVM、Adaboost到随机森林、Deep Learning. 《Deep Learning in Neural Networks: An Overview》 介绍:这是瑞士人工智能实验室Jurgen Schmidhuber写的最
uthash开源的hash函数实现
09-25
uthash开源的hash函数实现,里面的uthash.h可用
【STL】哈希表 uthash.h
yhhwatl的专栏
05-28 2299
哈希表的使用 uthash的基本用法 浅议cocos2d-x ActionManager
LeetCode1，167 两数之和 I，II（uthash.h）
忘之苡巛
07-19 746
原题目 两数之和I 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] ...
C语言哈希表uthash的使用方法详解
技术宅拯救世界
10-21 1778
uthash简介 由于C语言本身不存在哈希，但是当需要使用哈希表的时候自己构建哈希会异常复杂。因此，我们可以调用开源的第三方头文件，这只是一个头文件：uthash.h。我们需要做的就是将头文件复制到您的项目中，然后： #include "uthash.h" 由于uthash仅是头文件，因此没有可链接的库代码。 使用uthash添加，查找和删除通常是常数时间的操作，此哈希的目标是简约高效。它大约有1000行C。它会自动内联，因为它是作为宏实现的。 uthash还包括三个额外的头文件，主要提供链表，动态数组和
uthash.h 哈希表怎么用
Title404
09-17 705
uthash 哈希表 使用方法
C语言 | 开源库uthash.h的使用
张登雨的博客
03-06 1668
C中uthash.h哈希表的使用
C语言math.h库详解：函数与示例
此外，还列举了math.h中一些主要函数的实例，如fabs用于计算double型参数的绝对值，ceil和floor分别返回大于或小于参数的最接近整数，fmod用于获取浮点数除法的余数等。" 在C语言编程中，`math.h`头文件提供了一套...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值