关于整理工作中用到的链表和哈希表的简单操作

最新推荐文章于 2024-04-20 00:50:23 发布
最新推荐文章于 2024-04-20 00:50:23 发布
阅读量802 收藏 3
点赞数
分类专栏： linuxc 数据结构 文章标签： c语言 链表 struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzl2563852/article/details/60753233
版权

linux c 关于链表和哈希表的简单操作

  • 单向链表
  • 单向循环链表
  • 双向链表
  • 双向循环链表
  • 哈希表

单向链表

定义

typedef struct tagSL_NODE
{
    struct tagSL_NODE *next;
} sl_node_s;
#define SL_ENTRY(ptr, type, member) (container_of(ptr, type, member))
typedef struct tagSL_HEAD
{
    sl_node_s *pfirst;
} sl_head_s;
static inline void api_sl_init(IN sl_head_s *plist);
static inline void api_sl_node_init(IN sl_node_s *pnode);
static inline BOOL_T api_sl_is_empty(IN const sl_head_s *plist);
static inline sl_node_s *api_sl_first(IN const sl_head_s *plist);
static inline sl_node_s *api_sl_next(IN const sl_node_s *pnode);
static inline void api_sl_add_head(IN sl_head_s *plist, IN sl_node_s *pnode);
static inline sl_node_s *api_sl_del_head(IN sl_head_s *plist);
static inline void api_sl_add_after(IN sl_head_s *plist, IN sl_node_s *prev, IN sl_node_s *pinst);
static inline sl_node_s *api_sl_del_after(IN sl_head_s *plist, IN sl_node_s *prev);
static inline void api_sl_del(IN sl_head_s *plist, IN const sl_node_s *pnode);
static inline void api_sl_append(IN sl_head_s *pdstlist, IN sl_head_s *psrclist);
static inline void api_sl_free_all(IN sl_head_s *plist, IN void (*pfFree)(void *));

/************************************宏定义**********************************/
#define SL_FOREACH(plist, pnode) \
    for((pnode) = api_sl_first(plist); \
        NULL != (pnode); \
        (pnode) = api_sl_next(pnode))
#define SL_FOREACH_SAFE(plist, pnode, next) \
    for((pnode) = api_sl_first(plist); \
        (NULL != (pnode)) && ({(next) = api_sl_next(pnode); BOOL_TRUE;}); \
        (pnode) = (next))
#define SL_FOREACH_PREVPTR(plist, pnode, prev) \
    for((pnode) =  api_sl_first(plist), (prev) = (sl_node_s *)NULL; \
        NULL != (pnode); \
        (void)({(prev) = (pnode); (pnode) = api_sl_next(pnode);}))
#define SL_ENTRY_FIRST(plist, type, member) \
    (api_sl_is_empty(plist) ? NULL : SL_ENTRY(api_sl_first(plist), type, member))
#define SL_ENTRY_NEXT(pstEntry, member) \
    (NULL == (pstEntry) ? NULL: \
        (NULL == api_sl_next(&((pstEntry)->member))) ? NULL : \
            SL_ENTRY(api_sl_next(&((pstEntry)->member)), typeof(*(pstEntry)), member))
#define SL_FOREACH_ENTRY(plist, pstEntry, member) \
    for((pstEntry) = SL_ENTRY_FIRST(plist, typeof(*(pstEntry)), member); \
        NULL != (pstEntry); \
        (pstEntry) = SL_ENTRY_NEXT(pstEntry, member))
#define SL_FOREACH_ENTRY_SAFE(plist, pstEntry, nextEntry, member) \
    for((pstEntry) = SL_ENTRY_FIRST(plist, typeof(*(pstEntry)), member); \
        (NULL != (pstEntry)) && \
        ({(nextEntry) = SL_ENTRY_NEXT(pstEntry, member); BOOL_TRUE;}); \
        (pstEntry) = (nextEntry))
#define SL_FOREACH_ENTRY_PREVPTR(plist, pstEntry, prevEntry, member) \
    for((pstEntry) = SL_ENTRY_FIRST(plist, typeof(*(pstEntry)), member), \
        (prevEntry) = NULL ; \
        NULL != (pstEntry); \
        (void)({(prevEntry) = (pstEntry); (pstEntry) = SL_ENTRY_NEXT(prevEntry);}))

简单使用

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

typedef struct {
    sl_node_s node;
    int data;
}sl_data_s;

sl_head_s g_sl_list;
sl_data_s *get_node (int data)
{
    sl_data_s *pnode = NULL;

    pnode = (sl_data_s *)malloc (sizeof(sl_data_s));
    if (pnode == NULL)
    {
        return NULL;
    }
    api_sl_node_init(&pnode->node);
    pnode->data = data;

    return pnode;
}
void show_node()
{
    sl_node_s *curr = NULL, *next = NULL;
    sl_data_s *node = NULL;
    SL_FOREACH_SAFE(&g_sl_list, curr, next)
    {
        if (curr != NULL)
        {
            node = (sl_data_s *)curr;
            printf("%d -> ", node->data);

        }

    }
    printf("\n");

    return;
}

int main ()
{
    sl_data_s *pnode = NULL;
    api_sl_init(&g_sl_list);

    pnode = get_node(2);
    if (pnode != NULL)
    {
        api_sl_add_head(&g_sl_list, &pnode->node);

    }
    show_node();
    pnode = get_node(3);
    if (pnode != NULL)
    {
        api_sl_add_head(&g_sl_list, &pnode->node);

    }
    show_node();
    api_sl_del_after(&g_sl_list, &pnode->node);
    show_node();
    pnode = get_node(5);
    if (pnode != NULL)
    {
        api_sl_add_head(&g_sl_list, &pnode->node);

    }
    show_node();
    api_sl_add_after(&g_sl_list, &pnode->node, &(get_node(8))->node); 


    show_node();
    api_sl_del_head(&g_sl_list);
    show_node();

    return 0;
}

单向循环链表

typedef struct tagSTQ_NODE
{
    struct tagSTQ_NODE *next;
} stq_node_s;
#define STQ_ENTRY(ptr, type, member)  (container_of(ptr, type, member))
typedef struct tagSTQ_HEAD
{
    stq_node_s *pfirst;
    stq_node_s *plast;
} stq_head_s;
static inline void api_stq_init(IN stq_head_s *plist);
static inline void api_stq_node_init(IN stq_node_s *pnode);
static inline BOOL_T api_stq_is_empty(IN const stq_head_s *plist);
static inline stq_node_s *api_stq_first(IN const stq_head_s *plist);
static inline stq_node_s *api_stq_last(IN const stq_head_s *plist);
static inline stq_node_s *api_stq_next(IN const stq_node_s *pnode);
static inline void api_stq_add_head(IN stq_head_s *plist, IN stq_node_s *pnode);
static inline stq_node_s *api_stq_del_head(IN stq_head_s *plist);
static inline void api_stq_add_tail(IN stq_head_s *plist, IN stq_node_s *pnode);
static inline void api_stq_add_after(IN stq_head_s *plist, IN stq_node_s *prev, IN stq_node_s *pinst);
static inline stq_node_s *api_stq_del_after(IN stq_head_s *plist, IN stq_node_s *prev);
static inline void api_stq_del(IN stq_head_s *plist, IN const stq_node_s *pnode);
static inline void api_stq_append(IN stq_head_s *pdstlist, IN stq_head_s *psrclist);
static inline void api_stq_free_all(IN stq_head_s *plist, IN void (*pfFree)(void *));

/************************************宏定义**********************************/
#define STQ_FOREACH(plist, pnode) \
    for((pnode) = api_stq_first(plist); \
        NULL != (pnode); \
        (pnode) = api_stq_next(pnode))
#define STQ_FOREACH_SAFE(plist, pnode, next) \
    for((pnode) = api_stq_first(plist); \
        (NULL != (pnode)) && ({(next) = api_stq_next(pnode); BOOL_TRUE;}); \
        (pnode) = (next))
#define STQ_FOREACH_PREVPTR(plist, pnode, prev) \
    for((pnode) =  api_stq_first(plist), (prev) = (stq_node_s *)NULL; \
        NULL != (pnode); \
        (void)({(prev) = (pnode); (pnode) = api_stq_next(pnode);}))
#define STQ_ENTRY_FIRST(plist, type, member) \
    (api_stq_is_empty(plist) ? NULL : STQ_ENTRY(api_stq_first(plist), type, member))
#define STQ_ENTRY_LAST(plist, type, member) \
    (api_stq_is_empty(plist) ? NULL : STQ_ENTRY(api_stq_last(plist), type, member))
#define STQ_ENTRY_NEXT(pstEntry, member) \
    (NULL == (pstEntry) ? NULL: \
        (NULL == api_stq_next(&((pstEntry)->member))) ? NULL : \
            STQ_ENTRY(api_stq_next(&((pstEntry)->member)), typeof(*(pstEntry)), member))
#define STQ_FOREACH_ENTRY(plist, pstEntry, member) \
    for((pstEntry) = STQ_ENTRY_FIRST(plist, typeof(*(pstEntry)), member); \
        NULL != (pstEntry); \
        (pstEntry) = STQ_ENTRY_NEXT(pstEntry, member))
#define STQ_FOREACH_ENTRY_SAFE(plist, pstEntry, nextEntry, member) \
    for((pstEntry) = STQ_ENTRY_FIRST(plist, typeof(*(pstEntry)), member); \
        (NULL != (pstEntry)) && \
        ({(nextEntry) = STQ_ENTRY_NEXT(pstEntry, member); BOOL_TRUE;}); \
        (pstEntry) = (nextEntry))
#define STQ_FOREACH_ENTRY_PREVPTR(plist, pstEntry, prevEntry, member) \
    for((pstEntry) = STQ_ENTRY_FIRST(plist, typeof(*(pstEntry)), member), \
        (prevEntry) = NULL ; \
        NULL != (pstEntry); \
        (void)({(prevEntry) = (pstEntry); (pstEntry) = STQ_ENTRY_NEXT(prevEntry);}))

双向链表

typedef struct tagDL_NODE
{
    struct tagDL_NODE *next;
    struct tagDL_NODE **ppstpre; /* the address of previous element's next */
} dl_node_s;
#define DL_ENTRY(ptr,type, member) (container_of(ptr, type, member))
#define DL_NODE_FROM_PPRE(ppstpre) (container_of(ppstpre, dl_node_s, next))
#define DL_ENTRY_FROM_PPRE(ppstpre, type, member) \
        DL_ENTRY(DL_NODE_FROM_PPRE(ppstpre), type, member)
typedef struct tagDL_HEAD
{
    dl_node_s *pfirst;
} dl_head_s;
static inline void api_dl_init(IN dl_head_s *plist);
static inline void api_dl_node_init(IN dl_node_s *pnode);
static inline BOOL_T api_dl_is_empty(IN const dl_head_s *plist);
static inline dl_node_s *api_dl_first(IN const dl_head_s *plist);
static inline dl_node_s *api_dl_next(IN const dl_node_s *pnode);
static inline dl_node_s *api_dl_prev(IN const dl_node_s *pnode);
static inline void api_dl_del(IN const dl_node_s *pnode);
static inline void api_dl_add_head(IN dl_head_s *plist, IN dl_node_s *pnode);
static inline dl_node_s *api_dl_del_head(IN dl_head_s *plist);
static inline void api_dl_add_after(IN dl_node_s *prev, IN dl_node_s *pinst);
static inline void api_dl_add_after_ptr(IN dl_node_s **ppstpre, IN dl_node_s *pinst);
static inline void api_dl_add_before(IN dl_node_s *prev, IN dl_node_s *pinst);
static inline void api_dl_append(IN dl_head_s *pdstlist, IN dl_head_s *psrclist);
static inline void api_dl_free_all(IN dl_head_s *plist, IN void (*pfFree)(void *));

/************************************宏定义**********************************/
#define DL_FOREACH(plist, pnode) \
    for((pnode) = api_dl_first(plist); \
        NULL != (pnode); \
        (pnode) = api_dl_next(pnode))
#define DL_FOREACH_SAFE(plist, pnode, next) \
    for((pnode) = api_dl_first(plist); \
        (NULL != (pnode)) && ({(next) = api_dl_next(pnode); BOOL_TRUE;}); \
        (pnode) = (next))
#define DL_FOREACH_PREVPTR(plist, pnode, ppstpre) \
    for((pnode) =  api_dl_first(plist), (ppstpre) = &((plist)->pfirst); \
        NULL != (pnode); \
        (void)({(ppstpre) = &((pnode)->next); (pnode) = api_dl_next(pnode);}))
#define DL_ENTRY_FIRST(plist, type, member) \
    (api_dl_is_empty(plist) ? NULL : DL_ENTRY(api_dl_first(plist), type, member))
#define DL_ENTRY_NEXT(pstEntry, member) \
    (NULL == (pstEntry) ? NULL: \
        (NULL == api_dl_next(&((pstEntry)->member))) ? NULL : \
            DL_ENTRY(api_dl_next(&((pstEntry)->member)), typeof(*(pstEntry)), member))
#define DL_ENTRY_PREV(pstEntry, member) \
    (NULL == (pstEntry) ? NULL: \
        (NULL == api_dl_prev(&((pstEntry)->member))) ? NULL : \
            DL_ENTRY(api_dl_prev(&((pstEntry)->member)), typeof(*(pstEntry)), member))
#define DL_FOREACH_ENTRY(plist, pstEntry, member) \
    for((pstEntry) = DL_ENTRY_FIRST(plist, typeof(*(pstEntry)), member); \
        NULL != (pstEntry); \
        (pstEntry) = DL_ENTRY_NEXT(pstEntry, member))
#define DL_FOREACH_ENTRY_SAFE(plist, pstEntry, nextEntry, member) \
    for((pstEntry) = DL_ENTRY_FIRST(plist, typeof(*(pstEntry)), member); \
        (NULL != (pstEntry)) && \
        ({(nextEntry) = DL_ENTRY_NEXT(pstEntry, member); BOOL_TRUE;}); \
        (pstEntry) = (nextEntry))
#define DL_FOREACH_ENTRY_PREVPTR(plist, pstEntry, ppstpre, member) \
    for((pstEntry) = DL_ENTRY_FIRST(plist, typeof(*(pstEntry)), member), \
        (ppstpre) = &((plist)->pfirst); \
        NULL != (pstEntry); \
        (void)({(ppstpre) = &((pstEntry)->member.next); (pstEntry) = DL_ENTRY_NEXT(pstEntry, member);}))

双向循环链表

typedef struct tagDTQ_NODE
{
    struct tagDTQ_NODE *prev;
    struct tagDTQ_NODE *next;
} dtq_node_s;
#define DTQ_ENTRY(ptr, type, member) (container_of(ptr, type, member))
typedef struct tagDTQ_HEAD
{
    dtq_node_s stHead;
} dtq_head_s;
static inline void api_dtq_init(IN dtq_head_s *plist);
static inline void api_dtq_node_init(IN dtq_node_s *pnode);
static inline BOOL_T api_dtq_is_empty(IN const dtq_head_s *plist);
static inline dtq_node_s *api_dtq_first(IN const dtq_head_s *plist);
static inline dtq_node_s *api_dtq_last(IN const dtq_head_s *plist);
static inline BOOL_T api_dtq_is_end_ofq(IN const dtq_head_s *plist, IN const dtq_node_s *pnode);
static inline dtq_node_s *api_dtq_prev(IN const dtq_node_s *pnode);
static inline dtq_node_s *api_dtq_next(IN const dtq_node_s *pnode);
static inline void api_dtq_add_after(IN dtq_node_s *prev, IN dtq_node_s *pinst);
static inline void api_dtq_add_before(IN dtq_node_s *next, IN dtq_node_s *pinst);
static inline void api_dtq_del(IN dtq_node_s *pnode);
static inline void api_dtq_add_head(IN dtq_head_s *plist, IN dtq_node_s *pnode);
static inline dtq_node_s *api_dtq_del_head(IN dtq_head_s *plist);
static inline void api_dtq_add_tail(IN dtq_head_s *plist, IN dtq_node_s *pnode);
static inline dtq_node_s *api_dtq_del_tail(IN dtq_head_s *plist);
static inline void api_dtq_append(IN dtq_head_s *pdstlist, IN dtq_head_s *psrclist);
static inline void api_dtq_free_all(IN dtq_head_s *plist, IN void (*pfFree)(void 
*));


/************************************宏定义**********************************/
#define DTQ_FOREACH(plist, pnode) \
    for((pnode) = api_dtq_first(plist); \
        (pnode) != &((plist)->stHead); \
        (pnode) = api_dtq_next(pnode))
#define DTQ_FOREACH_SAFE(plist, pnode, nextnode) \
    for((pnode) = (plist)->stHead.next; \
        (pnode) != &((plist)->stHead) && \
        ({(nextnode) = api_dtq_next(pnode); BOOL_TRUE;}); \
        (pnode) = (nextnode))
#define DTQ_FOREACH_REVERSE(plist, pnode) \
    for((pnode) =  api_dtq_last(plist); \
        (BOOL_TRUE) != api_dtq_is_end_ofq(plist, pnode); \
        (pnode) = api_dtq_prev(pnode)
#define DTQ_FOREACH_REVERSE_SAFE(plist, pnode, prev) \
    for((pnode) = api_dtq_last(plist); \
        (BOOL_TRUE != api_dtq_is_end_ofq(plist, pnode)) && \
        ({(prev) = api_dtq_prev(pnode); BOOL_TRUE;}); \
        (pnode) = (prev))
#define DTQ_ENTRY_FIRST(plist, type, member) \
    ({dtq_node_s *pnode__Tmp__Mx = api_dtq_first(plist); \
    (NULL == pnode__Tmp__Mx) ? NULL : DTQ_ENTRY(pnode__Tmp__Mx, type, member);})
#define DTQ_ENTRY_LAST(plist, type, member) \
    ({dtq_node_s *pnode__Tmp__Mx = api_dtq_last(plist); \
    (NULL == pnode__Tmp__Mx) ? NULL : DTQ_ENTRY(pnode__Tmp__Mx, type, member);})
#define DTQ_ENTRY_NEXT(plist, pstEntry, member) \
    (api_dtq_is_end_ofq(plist, (NULL == (pstEntry) ? NULL : api_dtq_next(&((pstEntry)->member)))) ? \
    NULL : \
    DTQ_ENTRY(api_dtq_next(&((pstEntry)->member)), typeof(*(pstEntry)), member))
#define DTQ_ENTRY_PREV(plist, pstEntry, member) \
    (api_dtq_is_end_ofq(plist, (NULL == (pstEntry) ? NULL : api_dtq_prev(&((pstEntry)->member)))) ? \
    NULL : \
    DTQ_ENTRY(api_dtq_prev(&((pstEntry)->member)), typeof(*(pstEntry)), member))
#define DTQ_FOREACH_ENTRY(plist, pstEntry, member) \
    for((pstEntry) = DTQ_ENTRY((plist)->stHead.next, typeof(*(pstEntry)), member); \
        ((&(pstEntry)->member != &(plist)->stHead) || ({pstEntry = NULL; BOOL_FALSE;})); \
        (pstEntry) = DTQ_ENTRY((pstEntry)->member.next, typeof(*(pstEntry)), member))
#define DTQ_FOREACH_ENTRY_SAFE(plist, pstEntry, nextEntry, member) \
    for((pstEntry) = DTQ_ENTRY((plist)->stHead.next, typeof(*(pstEntry)), member); \
        (((&(pstEntry)->member != &(plist)->stHead) && \
        ({(nextEntry) = DTQ_ENTRY((pstEntry)->member.next, typeof(*(pstEntry)), member); BOOL_TRUE;})) || \
        ({(pstEntry) = NULL; BOOL_FALSE;})); \
        (pstEntry) = (nextEntry))
#define DTQ_FOREACH_ENTRY_REVERSE(plist, pstEntry, member) \
    for ((pstEntry) = DTQ_ENTRY_LAST(plist, typeof(*(pstEntry)), member); \
        NULL != (pstEntry); \
        (pstEntry) = DTQ_ENTRY_PREV(plist, pstEntry, member))
#define DTQ_FOREACH_ENTRY_REVERSE_SAFE(plist, pstEntry, prevEntry, member) \
    for((pstEntry) = DTQ_ENTRY_LAST(plist, typeof(*(pstEntry)), member); \
        (NULL !=(pstEntry)) && \
        ({(prevEntry) = DTQ_ENTRY_PREV(plist, pstEntry, member); BOOL_TRUE;}); \
        (pstEntry) = (prevEntry))

哈希表

源码路径

https://github.com/TrailHuang/data_structure

Trail丶
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
内嵌式链表的实现
xingqilui126com的专栏
10-18 1325
内嵌式双向链表的实现，记录下来留着以后用得到的地方，应该适用于大部分场景！ >>>>>list.h>>>>> #ifndef _LIST_H_ #define _LIST_H_ typedef struct tagDTQ_NODE { struct tagDTQ_NODE *pstPrev; struct tagDTQ_NODE *pstNext; }DTQ_NODE_S;
【数据结构】哈希表（Map和Set）
haoshaokang_的博客
06-07 1295
3️⃣当堆中不够K个元素时，就直接入堆，入够K个元素之后，此时按照比较规则，堆顶元素一定是出现频率最小的，如果堆中还有其他元素和堆顶元素频率相同，那堆顶元素应该是字典序靠后的。4️⃣再接着遍历集合元素，如果当前元素比堆顶元素频率高，则出堆顶元素，入当前元素；如果当前元素和堆顶元素频率一样高，再比较字典序，如果堆顶元素靠后，则出堆顶元素，入当前元素。5️⃣最终依次出堆顶元素到List中，然后逆序List即可。
链表-哈希表 详解
qq_43205267的博客
11-10 2329
链表-哈希表 详解
哈希表(哈希映射)_&gt；&gt；的算法，2024年最新阿里P8架构师网络安全大厂面试题总结
最新发布
2401_83974142的博客
04-20 304
有一个公司，当有新的员工来报道时，要求将该员工的信息加入(id,性别，年龄，名字，住址…),当输入该员工的id时，要求查找到该员工所有信息。如果我们搜索 1987，我们将使用相同的哈希函数将1987 映射到 2。例如，如果我们搜索 23，将映射 23 到 3，并在桶 3 中搜索。Java的官方文档建议我们在初始化哈希表时尽量指定哈希表的容量，以避免扩容所带来的性能消耗！，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。**插入：**我们通过哈希函数解析键，将它们映射到相应的桶中。
Hash 哈希表
m0_52343363的博客
04-23 1254
我们学习了数据结构,其实都在做一件事情那就是 数据的结构 无论是学了啥？目的都是为了1.1 哈希表的定义（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。remark: 通过某种映射关系 比方将你映射为 阿兰图灵 那么在这个名人散列表查找到图灵时就等于找到了你。
链式哈希表
qq_41721746的博客
05-24 3758
线性哈希表的缺陷 但是链式哈希表可以采用分段的锁，这样既保证了线程安全，又有一定的并发量，提高了效率。当前我们库里面无序的关联容器并没有实现多线程中的线程安全问题，就是并没有去加锁，但是这并不妨碍当我们真正想要实现一个线程安全，能够直接用在多线程环境下的基于哈希表实现的无序关联容器，我们在代码上可以通过分段锁来实现。
链表HuffmanTree.zip
03-18
链表和哈夫曼树（Huffman Tree）是两种在计算机科学中常用的数据结构，它们在不同的场景下有着各自独特的应用。在这个“链表HuffmanTree.zip”压缩包中，可能包含了一些关于这两种数据结构的资料整理，让我们来详细...
Java知识框架梳理，常见的面试题整理和一些工作过程中的实践
06-29
以上知识点构成了Java知识框架的主要部分，而"常见的面试题整理"可能涉及这些领域的经典问题，例如“解释什么是Java中的深拷贝和浅拷贝”、“描述一下单例模式的实现方式”等。"一些工作过程中的最佳实践"可能涵盖...
易语言常用算法整理
07-22
易语言是一种以中文编程...这些算法是计算机科学的基础，易语言常用算法整理中的源码可以作为学习和实践的参考，帮助开发者更好地理解和运用这些概念，提升编程能力。通过实际操作，可以更直观地感受算法的魅力和效率。
Java 中的HashMap详解和使用示例_动力节点Java学院整理
08-30
HashMap基于哈希表的数据结构实现，具有快速查找、插入和删除的特点。本文将详细介绍HashMap的基本概念、构造函数、数据结构以及源码解析。 ### 1. HashMap简介 HashMap是一个散列表，它通过哈希函数将键映射到...
易语言常用算法整理.rar
03-22
- **链表**：非连续存储，便于插入和删除操作。 - **树**：如二叉树、平衡树（AVL、红黑树）、B树、B+树等，广泛应用于数据库索引。 8. **数学算法**： - **质因数分解**：将一个合数表示为若干质数的乘积。 - ...
哈希表【Hash Table】原理、特点及实现方式！一文彻底搞定哈希表！
KIDfengKID的博客
07-01 1843
详细易懂hash table
哈希表(哈希映射)
weixin_49329785的博客
09-22 440
基本介绍 散列表(Hash table,也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构，也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 哈希表的作用相当于一个缓存层 哈希表的内存布局图 哈希表例题代码实现 有一个公司，当有新的员工来报道时，要求将该员工的信息加入(id,性别，年龄，名字，住址...),当输入该员工的id时，要求查找到该员工所有信息。 要求： 不使用数据库，速度越.
算法入门9-哈希表、有序表和链表的使用
jinyangjie的博客
12-24 963
这是个过渡篇章，简单介绍哈希表、有序表和链表的使用，这是刷算法题必备的基础知识。哈希表、有序表和链表的深入实现原理，会在后续篇章中介绍，目前暂不需要。
哈希表（数组+链表）
qq_51728440的博客
03-15 239
模拟哈希表 1.雇员Emp(节点)类 2.EmpLinkedList(链表)类 3.HashTab哈希表类。内容包括对哈希表的添加、查找(根据输入的员工id)、删除(根据输入的员工id)以及显示。哈希表可以将常访问的数据存储在缓存层，以缓解数据库的访问。
算法篇07---链表、哈希表
S1406793的博客
01-19 1271
一、链表 二、哈希表 python的字典、集合都是它实现的。
哈希表（拉链法）
adzn1的博客
03-10 2090
> 开散列法又叫链地址法(开链法)。 开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个 桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。 设元素的关键码为37, 25, 14, 36, 49, 68, 57, 11, 散列表为HT[12]，表的大小为12，散列函数为Hash(x) = x % 11
思考：在实际工作中什么时候用数组、链表、栈、队列、平衡二叉树？
HKpeng的学习记录
02-27 3034
数组：当你明确需要存储的数据的个数或者数据的个数一定会在某个范围内的时候（数据的个数最好在1024*1024之内），而且希望直接用下标法访问，希望不需要手动释放存储数据的内存空间！ 链表：存储的数据的长度是动态的，而且不需要对数据进行排序，数据和数据之间是一对一的关系（满足线性结构）。 在实际工作中，数组和链表可以解决大部分的问题！！！ 栈：需要先进后出的时候 队列：需要先进先出的时候 在实际工作...
foreach语法
热门推荐
fxkcsdn的博客
08-02 1万+
foreach语法 1.foreach用于数组： Java SE5 引入了一种新的更加简洁的for语法用于数组和容器，，即foreach语法，表示不必创建int变量去对由访问项构成的序列进行计数，foreach将自动产生每一项。 例如，假设有一个float数组，我们要选取该数组中的每一个元素：  public class ForEachFloat { public static void
1_数据结构基本算法整理 (自动保存的).docx
12-29
另外，数据结构基本算法整理中还包括了一些常用的查找算法，如二分查找、顺序查找、哈希查找等。这些算法可以帮助我们在海量数据中快速地定位目标数据，对于数据处理和信息检索有着重要的意义。另外，还有一些图算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值