哈希表、二叉搜索树key和key value（判断是否存在、字典.....）

最新推荐文章于 2024-02-21 13:49:02 发布
最新推荐文章于 2024-02-21 13:49:02 发布
阅读量1.9k 收藏 3
点赞数 1
文章标签： 哈希表/搜索二叉树应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sophia__yu/article/details/80301388
版权

key：可以判断一个单词是否拼写错误，判断网名是否存在等等；
key value:实现中英文字典，统计单词出现次数等等；key value 需要在结构体中在存一个值value（中文、出现次数）
代码如下：
BinarySearchTree.h

#pragma once
//利用二叉搜索树 key value:中英文翻译
typedef char*  BSTKeyType;
typedef char*  BSTValueType;//翻译
//typedef int  BSTValueType;//统计次数
typedef struct BSTreeNode
{
    struct BSTreeNode *left;
    struct BSTreeNode *right;
    BSTKeyType _key;
    BSTValueType _value;
}BSTreeNode;

int BSTreeInsert(BSTreeNode **pptree, BSTKeyType x, BSTValueType value);//插入数据
BSTreeNode *BuyBSTreeNode(BSTKeyType x, BSTValueType value);//创建结点
void BSTreeInOrder(BSTreeNode *ptree);//中序遍历
const BSTreeNode *FindBSTreeNode(BSTreeNode *ptree, BSTKeyType key);//查找元素
int BSTreeNodeRemove(BSTreeNode **pptree, BSTKeyType x);//删除

int BSTreeInsertR(BSTreeNode **pptree, BSTKeyType x, BSTValueType value);//递归插入
 BSTreeNode* BSTreeFindNodeR(BSTreeNode *pptree, BSTKeyType key);//递归查找
int BSTreeRemoveR(BSTreeNode **pptree, BSTKeyType key);//递归删除

BinarySearchTree.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"BinarySearchTree.h"
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
BSTreeNode *BuyBSTreeNode(BSTKeyType key, BSTValueType value)//创建结点
{
    BSTreeNode *newnode = (BSTreeNode *)malloc(sizeof(BSTreeNode));
    if (newnode == NULL)
        return NULL;
    else
    {
        newnode->_key = key;
        newnode->_value = value;
        newnode->left = NULL;
        newnode->right = NULL;
        return newnode;
    }
}
int BSTreeInsert(BSTreeNode **pptree, BSTKeyType key, BSTValueType value)//插入数据
{
    BSTreeNode *node = BuyBSTreeNode(key,value);
    BSTreeNode *parent = NULL, *cur = *pptree;
    if (*pptree == NULL)
    {
        *pptree = node;
        return 0;
    }
    while (cur)
    {
        if (strcmp(cur->_key, key)< 0)
        {
            parent = cur;
            cur = cur->right;
        }
        else if (strcmp(cur->_key, key) > 0)
        {
            parent = cur;
            cur = cur->left;
        }
        else
            return -1;//插入元素已经存在，则不进行插入
    }
    if (parent->_key > key)
        parent->left = node;
    else
        parent->right = node;
    return 0;
}
void BSTreeInOrder(BSTreeNode *ptree)//中序遍历
{
    if (ptree == NULL)
        return;
    BSTreeInOrder(ptree->left);
    printf("%s:%s  ", ptree->_key,ptree->_value);
    BSTreeInOrder(ptree->right);
}
const BSTreeNode *FindBSTreeNode(BSTreeNode *ptree, BSTKeyType key)//查找元素
{
    assert(ptree);
    BSTreeNode *cur = ptree;
    while (cur)
    {
        if (strcmp(cur->_key, key) < 0)
            cur = cur->right;
        else if (strcmp(cur->_key, key)> 0)
            cur = cur->left;
        else
            return cur;
    }
    return NULL;
}

int BSTreeNodeRemove(BSTreeNode **pptree, BSTKeyType key)//删除
{
    assert(*pptree);
    BSTreeNode *cur = *pptree, *parent = *pptree;
    while (cur)//找到删除结点
    {
        if (strcmp(cur->_key, key)< 0)
        {
            parent = cur;
            cur = cur->right;
        }
        else if (strcmp(cur->_key, key)> 0)
        {
            parent = cur;
            cur = cur->left;
        }
        else
            break;
    }
    if (cur->left == NULL)//左为空
    {
        if (strcmp(parent->_key, key) < 0)
            parent->right = cur->right;
        else if (strcmp(parent->_key, key)> 0)
            parent->left = cur->right;
        else
        {
            BSTreeNode *subleft, *parentnode = cur;
            subleft = cur->right;
            if (subleft)
            {
                while (subleft->left)
                {
                    parentnode = subleft;
                    subleft = subleft->left;
                }
                cur->_key= subleft->_key;
                if (parentnode->right == subleft)
                    parentnode->right = subleft->right;
                else
                    parentnode->left = subleft->right;
                free(subleft);
                subleft = NULL;
            }
            else
            {  //说明*pptree是根结点,而且只有这一个根结点
                *pptree = NULL;
            }
        }
        return 0;
    }
    if (cur->right == NULL)//右为空
    {
        if (strcmp(parent->_key, key) < 0)
            parent->right = cur->left;
        else if (strcmp(parent->_key, key)> 0)
            parent->left = cur->left;
        else
        {
            //说明删除根结点
            BSTreeNode *subright, *parentnode = cur;
            subright = cur->left;
            if (subright)
            {
                while (subright->right)
                {
                    parentnode = subright;
                    subright = subright->right;
                }
                cur->_key= subright->_key;
                if (parentnode->left == subright)
                    parentnode->left = subright->left;
                else
                    parentnode->right = subright->left;
                free(subright);
                subright = NULL;
            }
        }
        return 0;
    }
    BSTreeNode *subleft, *parentnode = cur;
    subleft = cur->right;
    while (subleft->left)
    {
        parentnode = subleft;
        subleft = subleft->left;
    }
    cur->_key = subleft->_key;
    if (parentnode->left == subleft)
        parentnode->left = subleft->right;
    else
        parentnode->right = subleft->right;
    free(subleft);
    return 0;
}
int BSTreeInsertR(BSTreeNode **pptree, BSTKeyType key, BSTValueType value)//递归插入
{
    BSTreeNode *newnode = BuyBSTreeNode(key,value);
    if (*pptree == NULL)
    {    //由于pptree是二级指针，解引用后就是上一个pptree->left或pptree->right
         //具有天然的将父亲与孩子链接起来
        *pptree = newnode;
        return 0;
    }
    if (strcmp((*pptree)->_key ,key)<0)
    {
        return BSTreeInsertR(&(*pptree)->right, key,value);
    }
    else if (strcmp((*pptree)->_key, key)>0)
    {

        return BSTreeInsertR(&(*pptree)->left, key,value);
    }
    else
        return -1;
}
 BSTreeNode * BSTreeFindNodeR(BSTreeNode *pptree, BSTKeyType key)//递归查找
{
    if (pptree == NULL)
        return NULL;
    if (strcmp(pptree->_key, key)==0)//用字符串内容进行比较
        return pptree;
    else if (strcmp(pptree->_key, key) < 0)
        return BSTreeFindNodeR(pptree->right, key);
    else
        return BSTreeFindNodeR(pptree->left, key);
}
int BSTreeRemoveR(BSTreeNode **pptree, BSTKeyType key)//递归删除
{
    if (*pptree == NULL)//是空证明没有该结点，直接返回
        return  -1;
    if (strcmp((*pptree)->_key, key)<0)//在右子树里删除
        return BSTreeRemoveR(&(*pptree)->right, key);//递归删除
    else if (strcmp((*pptree)->_key, key)>0)//在左子树里删除
        return BSTreeRemoveR(&(*pptree)->left, key);
    else
    {
        BSTreeNode *del = *pptree;
        //叶子结点可以涵盖在左为空或者右为空中
        if ((*pptree)->left == NULL)//左为空
        {
            *pptree = (*pptree)->right;
            free(del);
            return 0;
        }
        else if ((*pptree)->right == NULL)//右为空
        {
            *pptree = (*pptree)->left;//利用二级指针解引用
            free(del);
            return 0;
        }
        else
        {
            BSTreeNode *subleft = (*pptree)->right;
            while (subleft->left)
                subleft = subleft->left;
            (*pptree)->_key = subleft->_key;
            //然后把subleft删除，参数里不能写成（subleft,subleft->_key),
            //因为subleft是局部变量
            return BSTreeRemoveR(&(*pptree)->right, subleft->_key);//递归删除
        }
    }
}
//void TestBinarySearch()
//{
//  //用字符串地址进行比较，行不通
//  BSTreeNode *tree = NULL;
//  char *str1 = malloc(5);
//  char *str2 = malloc(5);
//  strcpy(str1, "sort");
//  strcpy(str2, "sort");
//  BSTreeInsertR(&tree, str1);//插入数据
//  BSTreeInsertR(&tree, "tree");//插入数据
//  BSTreeInsertR(&tree, str2);//插入数据
//  printf("%d\n", BSTreeFindNodeR(tree, "sort"));//查找元素  
//  //如果用字符串地址比较字符串：将找不到sort ,并且插入两个sort,
//  //因为两个sort的地址不一样，所以要用字符串内容进行比较
//
//}
void TestBinaryTranslate()//key 是英文 vulue 是中文
{
    BSTreeNode *tree = NULL;
    BSTreeInsertR(&tree, "sort","排序");//插入数据
    BSTreeInsertR(&tree, "tree","树");//插入数据
    BSTreeInsertR(&tree, "pick","选择");//插入数据
    BSTreeInsertR(&tree, "sleep", "睡眠");//插入数据
    BSTreeInsertR(&tree, "insist", "坚持");//插入数据
    char *str = (char *)malloc(128);
    while (strcmp(str, "exit") != 0)
    {
        printf("请输入要查找的单词:\n");
        scanf("%s", str);
        BSTreeNode *node = BSTreeFindNodeR(tree, str);
        if (node)
        {
            printf("%s\n", node->_value);
        }
        else
            printf("该单词不存在\n");
    }   
}
void TestBinaryExistNum()//统计关键词出现的次数
{
    BSTreeNode *tree = NULL;
    char *fruit[] = { "香蕉","哈密瓜","西瓜","樱桃","香蕉","西瓜","哈密瓜","香蕉","菠萝" };
    int size = sizeof(fruit) / sizeof(fruit[0]);
    for (int i = 0; i < size; i++)
    {
        BSTreeNode *node = BSTreeFindNodeR(tree, fruit[i]);
        if (node == NULL)
        {
            BSTreeInsertR(&tree, fruit[i], 1);
        }
        else
            node->_value++;
    }
    BSTreeInOrder(tree);//中序遍历
}
//int main()
//{
//  TestBinaryTranslate();
//  TestBinaryExistNum();
//  system("pause");
//  return 0;
//}

这里写图片描述
这里写图片描述
Hash.h

#pragma once

typedef char* HTKeyType;
typedef int HTValueType;
enum STATUS
{
    EXIST,//该位置有数据
    DELETE,//该位置数据被删除
    EMPTY,//该位置没有数据
};
typedef struct HashNode
{
    HTKeyType _key;//数据
    HTValueType _value;
    enum STATUS _status;//状态
}HashNode;
typedef struct HashTable
{
    HashNode *hash;
    size_t _size;//哈希表里有效数据个数
    size_t _capacity;//哈希表大小
}HashTable;

void HTInit(HashTable *ht, int capacity);//哈希表初始化
//成功：0，失败-1
int HTInsert(HashTable *ht, HTKeyType key, HTValueType value);//插入数据
HashNode* HTFind(HashTable *ht, HTKeyType key);//查找
int HTRemove(HashTable *ht, HTKeyType key);//删除
void HTPrint(HashTable ht);//打印哈希表
void HTDestroy(HashTable *ht);//销毁哈希表

Hash.c

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<time.h>
#include"Hash.h"


//void TestHashTable()
//{
//  HashTable ht;
//  HTInit(&ht,11);//哈希表初始化
//  HTInsert(&ht, "pick");
//  HTInsert(&ht, "sleep");
//  HTInsert(&ht, "insist");
//  HTPrint(ht);//打印哈希表;
//  HTDestroy(&ht);
//}
void TestHashTableNum()
{
    HashTable ht;
    HTInit(&ht,0);//哈希表初始化
    char *fruit[] = { "香蕉","哈密瓜","西瓜","樱桃","香蕉","西瓜","哈密瓜","香蕉","菠萝" };
    int size = sizeof(fruit) / sizeof(fruit[0]);
    for (int i = 0; i < size; i++)
    {
        HashNode *node = HTFind(&ht, fruit[i]);
        if (node)//已经存在
        {
            node->_value++;
        }
        else
            HTInsert(&ht, fruit[i], 1);
    }
    HTPrint(ht);
}
int main()
{
    TestHashTableNum();
    system("pause");
    return 0;
}

int  GetPrime(HashTable *ht)
{
    const int _PrimeSize = 28;
    //该数据都是经过许多人测试的素数，能够满足需求，冲突较小
    static const unsigned long _PrimeList[_PrimeSize] = {

        53ul,97ul,193ul,389ul,769ul,

        1543ul,3079ul,6151ul,12289ul,

        24593ul,49157ul,98317ul,196613ul,

        393241ul,786433ul,1572869ul,3145739ul,

        6291469ul,12582917ul,25165843ul,50331653ul,

        100663319ul,201326611ul,402653189ul,805306457ul,

        1610612741ul, 3221225473ul, 4294967291ul

    };
    int index = 0;
    while (index < _PrimeSize)
    {
        if (ht->_capacity < _PrimeList[index])
        {
            return _PrimeList[index];
        }
        index++;
    }
    return _PrimeList[_PrimeSize - 1];
}
void HTInit(HashTable *ht, int capacity)//哈希表初始化
{
    assert(ht);
    ht->_size = 0;
    ht->_capacity = capacity;
    ht->_capacity = GetPrime(ht);//哈希表是素数大小，减少冲突
    ht->hash = (HashNode *)malloc(sizeof(HashNode)*ht->_capacity);
    assert(ht->hash);
    for (int i = 0; i < ht->_capacity; i++)
    {
        ht->hash[i]._status = EMPTY;//必须初始化状态
    }
}
size_t BKDRHash(char *str)//将字符串转成整数，可以取模
{
    size_t hash = 0;
    while (*str)
    {
        //hash=hash+*str;//  abcd aadd 
        hash = hash * 131 + *str;//*131冲突概率减少,其他值也可以 
        str++;
    }
    return hash;
}
int  HashFunc(HashTable * ht, HTKeyType key)
{
    return BKDRHash(key) % (ht->_capacity);
}
void CheckCapacity(HashTable *ht)
{
    //对于哈希表，并不是size=capacity时才扩容，如果size=capacity,那么当哈希表全部存满时，
    //无法用EMPTY判断查找数据,将会陷入死循环
    //而是当a=填入表中的数据/哈希表长度>=0.7时就要扩容，a越大，冲突可能性越大
    if (ht->_size * 10 / ht->_capacity >= 7)//负载因子大于0.7，需要扩容
    {
        //扩容：重新定义一个哈希表，将ht里的数据重新插入到newht,不能直接拷贝数据，
        //因为newht的表长发生变化，数据存放的位置也将发生变化
        HashTable newht;
        HTInit(&newht, ht->_capacity * 2);
        for (int i = 0; i < ht->_capacity; i++)
        {
            if (ht->hash[i]._status == EXIST)//必须加上
                HTInsert(&newht, ht->hash[i]._key,1);//插入数据
        }
        free(ht->hash);
        ht->hash = newht.hash;
        ht->_size = newht._size;
        ht->_capacity = newht._capacity;
    }
}
int HTInsert(HashTable *ht, HTKeyType key, HTValueType value)//插入数据
{
    assert(ht);
    CheckCapacity(ht);//判断容量
    int index = HashFunc(ht, key);
    int i = 1;
    while (ht->hash[index]._status == EXIST)//冲突，
    {
        int tmp = index;
        if (ht->hash[index]._key == key)
            return -1;
        index++;
        if (index == ht->_capacity)
        index = 0;//线性探测
        //二次探测
        /*index = tmp + i*i;
        i++;
        index = index%ht->_capacity;*/

    }
    ht->hash[index]._key = key;
    ht->hash[index]._value = value;
    ht->_size++;
    ht->hash[index]._status = EXIST;
    return 0;
}
void HTPrint(HashTable ht)//打印哈希表
{
    for (int i = 0; i < ht._capacity; i++)
    {
        if (ht.hash[i]._status == EXIST)
            printf("[EXIST:%s %d]  ", ht.hash[i]._key,ht.hash[i]._value);
    /*  else if (ht.hash[i]._status == DELETE)
            printf("DELETE:%s  ", ht.hash[i]._key);
        else
            printf("EMPTY:NULL ");*/
    }
    printf("\n");
}
HashNode *HTFind(HashTable *ht, HTKeyType key)//查找
{
    assert(ht);
    int index = HashFunc(ht, key);
    while (ht->hash[index]._status != EMPTY)
    {
        if (ht->hash[index]._key == key)
        {
            if (ht->hash[index]._status == EXIST)
                return &(ht->hash[index]);
            else//状态是删除且值相等，index后不会再存在该数据，直接返回
                return NULL;
        }
        index++;
        if (index == ht->_capacity)
            index = 0;
    }
    return NULL ;
}
int HTRemove(HashTable *ht, HTKeyType key)//删除
{
    assert(ht);
    int index = HashFunc(ht, key);
    while (ht->hash[index]._status != EMPTY)
    {
        if (ht->hash[index]._key == key)
        {
            if (ht->hash[index]._status == EXIST)
            {
                ht->hash[index]._status = DELETE;
                ht->_size--;
            }
            else
                return -1;//该数据已经被删除，无法再删除
        }
        index++;
        if (index == ht->_capacity)
            index = 0;
    }
    return -1;//没有找到该数据，删除失败
}
void HTDestroy(HashTable *ht)//销毁哈希表
{
    assert(ht);
    free(ht->hash);
    ht->hash = NULL;
    ht->_capacity = 0;
    ht->_size = 0;
}

这里写图片描述

sophia__yu
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
搜索二叉树——key/value模型
h1091068389的博客
05-24 462
KV模型搜索二叉树KV模型KV模型实现基本框架插入查找遍历删除测试代码 KV模型 和上一篇博客中介绍的key模型的搜索二叉树不同，KV模型的搜索二叉树对于每一个key值都有与之对应的唯一的value值，即key，value是配对出现的。这种做法在生活中也有类似的应用，例如：查找中英文字典时候，单词和其中文翻译就构成一种成对的结构。再比如统计某些情况单词字符的出现次数，也可以使用该模型。 KV模型实现 基本框架 template<class K, class V> struct BSTreeN
数据结构--二叉搜索树( KeyValue模型 )
【Dyson】的博客
08-29 1061
二叉搜索树应用 : 模拟实现一个简单的词典 实现功能 :  插入 ( 与二叉搜索树的插入方法一致 ) 删除 ( 与二叉搜索树的删除方法一致 ) 查询 ( 与二叉搜索树的查询方法一致 ) 打印 ( 中序打印 ) 二叉树搜索树的基本操作 : 传送门  https://blog.csdn.net/ds19980228/article/details/82120429 数据结构 :  ty...
数据结构—搜索二叉树key-value模型（数据类型char*）
精神小伙
08-24 584
#include&lt;malloc.h&gt; #include&lt;assert.h&gt; #include&lt;string.h&gt; typedef char* KeyType; typedef char* ValueType; typedef struct BSTreeNode { struct BSTreeNode* _left; struct BSTreeNo...
详解二叉搜索树 --- key模型和key/value模型
阿润菜菜的博客
04-17 1704
带你学习二叉搜索树 --- key模型和key/value模型
二叉搜索树的经典应用面试题(key&key-value模式）
HanSion.Z
08-25 1756
0.题目 1.假设给你一篇英语文章，又给你一个在这个英语文章中的英语单词，让你检查这个英语单词是否拼写正确。 2.假设给你一篇英语文章，如何才能求出文章中所有单词重复出现的次数呢？ 1.思路 1.第一题是key模式，我们可以将这篇英语文章中的所有正确的单词都放在一颗二叉搜索树中，然后在二叉搜索树搜索这个单词，如果在二叉搜索树中，则必然是正确的；如果不在，则是错误的。...
javascript，实现数据结构和算法题.zip
最新发布
06-17
6. 哈希表：也称为字典，通过键（key）来快速查找值（value）。JavaScript对象就是一种哈希表，但需要注意键必须是不可变的，通常是字符串。 7. 树：树形结构包含节点和边，每个节点可能有多个子节点。二叉树、AVL...
05_符号表.pdf
09-24
对于大规模数据，更高效的选择可能包括哈希表（如Java中的HashMap）或二叉查找树（如AVL树或红黑树），它们提供了更快的查找、插入和删除操作。然而，对于教学和理解基础概念，链表实现的符号表是一个很好的起点。
Key-Value双向快速高效查找类C,C++高手实现
01-28
这种模型非常适合用来做映射关系，因为查找速度快，通常采用哈希表或者二叉搜索树等数据结构实现。 在这个C或C++实现中，可能采用了哈希表作为基础数据结构。哈希表通过将键通过哈希函数转换为数组下标，可以实现...
OOP-dict--vc6.0.rar_Visual Dictionary
09-24
由于字典要求快速查找，通常会使用哈希表或二叉搜索树等数据结构，但这里选择链表可能是因为其简单性和实现效率。 **面向对象编程（OOP）** 在OOP中，程序被设计为一系列相互协作的对象，每个对象都有自己的属性...
(完整版)百度2012校园招聘C-C++笔试题.doc
11-13
一级分类作为外层哈希表的键，二级分类作为内层哈希表的键，三级分类作为数据项编号，值则为key-value对的集合。写入日志的时间复杂度为O(1)，读取日志的时间复杂度也为O(1)，前提是三级分类和数据项编号作为键可以...
[Data Structure & Algorithm] Hash那点事儿
weixin_33670713的博客
08-12 391
　　哈希表（Hash Table）是一种特殊的数据结构，它最大的特点就是可以快速实现查找、插入和删除。因为它独有的特点，Hash表经常被用来解决大数据问题，也因此被广大的程序员所青睐。为了能够更加灵活地使用Hash来提高我们的代码效率，今天，我们就谈一谈Hash的那点事。 1. 哈希表的基本思想 　　我们知道，数组的最大特点就是：寻址容易，插入和删除困难；而链表正好相反，寻址困难，而插入和删除...
【C++进阶：二叉树进阶】二叉搜索树的操作和key模型、key/value模型的实现 | 二叉搜索树的应用 | 二叉搜索树的性能分析
wh128341的博客
08-27 1508
从这里开始 C++ 的语法就告一段落了。二叉树在前面的数据结构和算法初阶中就讲过，本文取名为二叉树进阶是因为：我们之前说过，普通二叉树单纯的存储数据价值不大，因为仅仅是单纯的存储数据，你不如去使用顺序表和链表这样友善的多。它一定要套一种应用场景，二叉树的其中一个重要的应用场景就是我们本文中要学习的二叉搜索树。二叉搜索树又称搜索二叉树或二叉排序树 (如果你对下图的二叉搜索树中序遍历，你会发现它是有序并且升序的)，我们当前学习的搜索二叉树一般是不允许修改的，不过下面我们会学习搜索二叉树的 key_value 模
哈希表key-value
m0_46160753的博客
07-18 583
哈希表 (遇到问题：搜索值很慢，搜索键很快，看到一段话大意如下，尚未完全理解） 如果确定key 和value都是一一对应的话，可以把value和key调换位置来保存，这件检索速度就很快了，常数时间内就能完成。 如果不一一对应，不要用这种方式。 数据量大时时间复杂度太高O(n)， ...
深入解读Khash.h之 key、value相关操作
xuzhougeng blog
03-27 1037
key、value相关操作 当我们的键值对中的key=1001, 我们是不可能申请一个1001大小的数组用于存放key。否则，当我们要存放key=1和key=10001,我们就会浪费大量的内存空间。为了根据key查询对应的value，我们也需要申请同样大小的空间，那么就会浪费大量的空间。 实际上，我们只会申请和桶等大小的内容空间，来放key和value。 khkey_t *new_...
在java中哈希表判断某个元素是否存在的原理
weixin_46646600的博客
03-24 1719
在java中哈希表判断某个元素是否存在的原理 在本文中我们将介绍，在hash表中如何判断两个元素是否重复。 首先，我们们需要知么hash表是什么？ Hash表由称为离散表，是由数组加链表实现的一种数据结构。 在我们向hash表中存储数据时： 首先，使用hashCode方法，算出这个该元素的hash码，得到应该是在数组哪个下标指向的链表中，然后使用equals方法判断该链表中是否存在相同元素，如果...
哈希表是个啥
qq_37377611的博客
05-15 532
转载自微信公众号：编码之外 本文原创作者：庆哥小白 转载已获本人同意 大家可以关注关注庆哥的公众号，另外之前也探讨过哈希表（点击进入）
HashMap实例演示---key-value的类型
baidu_41191295的博客
09-21 3858
HashMap实例演示—key-value的类型 前言 对于HashMap的基础学习，相信网上已经有很多很详细的讲解，包括各种深入的源码的分析，各种拓展知识，以及各种和面试官的针锋相对。在这里，我不在进行源码的分析，而是直接用案例向大家演示一下HashMap的实现，让大家带着实际案例学习，我认为这是一个好的学习方式。 一.key为自定义对象，value为String类型 我们知道，HashMap是以key-value类型进行元素存储的集合，而集合里一般是存储对象的，所以我先以自定义对象作为key，Str
哈希表
qq_37377611的博客
04-24 400
哈希表hashtable(key，value) 就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。
【基础数据结构】哈希表
qq_62704693的博客
02-21 983
哈希表的全面概念与例题讲解
二叉搜索树与哈希表详解：Java实现与应用
二叉搜索树与哈希表解析.pptx.pptx是一份关于二叉搜索树和哈希表的深入讲解文档，主要涵盖了这两个重要数据结构的基础概念、实现原理、操作方法以及它们的应用。以下是详细的内容概述： 1. 二叉搜索树 - 基本概念...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值