6__字典和散列表__

于 2021-08-30 21:03:45 发布
阅读量124 收藏
点赞数
分类专栏： JS基础数据结构 文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bestadc/article/details/120005354
版权

字典和散列表

字典也称作映射、符号表或关联数组

// 默认变字符串String，把所有作为键名传入的对象转化为字符串
// 注意：item变量是对象的话会导致输出为 [object Object]
function defaultToString(item) {
  if (item === null) {
    return "NULL";
  } else if (item === undefined) {
    return "UNDEFINED";
  } else if (typeof item === "string" || item instanceof String) {
    return `${item}`;
  }
  return item.toString();
}
// ValuePair类中设置键和值
class ValuePair {
  constructor(key, value) {
    // 保存原始的key就好了，不需要转换成String
    this.key = key;
    this.value = value;
  }
  toString() {
    return `[#${this.key}: ${this.value}]`;
  }
}
// 字典开始
class Dictionary {
  constructor(toStrFn = defaultToString) {
    this.toStrFn = toStrFn;
    this.table = {};
  }
  // 向字典中添加新元素。如果key已经存在，那么已存在的 value会被新的值覆盖
  set(key, value) {
    if (key != null && value != null) {
      const tableKey = this.toStrFn(key);
      this.table[tableKey] = new ValuePair(key, value);
      return true;
    }
    return false;
  }
  // 从字典中检索一个值
  get(key) {
    const valuePair = this.table[this.toStrFn(key)];
    return valuePair == null ? undefined : valuePair.value;
    // 或者像下面这么写
    // if (this.hasKey(key)) {
    //   return this.table[this.toStrFn(key)];
    // }
    // return undefined;
  }
  // 检测一个键是否存在于字典中
  hasKey(key) {
    return this.table[this.toStrFn(key)] != null;
  }
  // 通过使用键值作为参数来从字典中移除键值对应的数据值
  remove(key) {
    if (this.hasKey(key)) {
      delete this.table[this.toStrFn(key)];
      return true;
    }
    return false;
  }
  // 将字典所包含的所有数值以数组形式返回
  values() {
    return this.keyValues().map((valuePair) => valuePair.value);
  }
  // 将字典所包含的所有键名以数组形式返回
  keys() {
    return this.keyValues().map((valuePair) => valuePair.key);
    // 或者像下面这样写
    // const keys = [];
    // const valuePairs = this.keyValues();
    // for (let i = 0; i < valuePairs.length; i++) {
    //   keys.push(valuePairs[i].key);
    // }
    // return keys;
  }
  // 将字典中所有[键，值]对返回
  keyValues() {
    return Object.values(this.table);
    // 或者像下面这样写
    // const valuePairs = [];
    // for (const k in this.table) {
    //   if (this.hasKey(k)) {
    //     valuePairs.push(this.table[k]);
    //   }
    // }
    // return valuePairs
  }
  // 迭代数据结构中每个值的方法
  forEach(callbackFn) {
    const valuePairs = this.keyValues();
    for (let i = 0; i < valuePairs.length; i++) {
      const result = callbackFn(valuePairs[i].key, valuePairs[i].value);
      if (result === false) {
        break;
      }
    }
  }
  // 检验字典是否为空
  isEmpty() {
    return this.size() === 0;
  }
  // 返回字典所包含值的数量。与数组的length属性类似
  size() {
    return Object.keys(this.table).length;
  }
  // 清空字典内容
  clear() {
    this.table = {};
  }
  toString() {
    if (this.isEmpty()) {
      return "";
    }
    const valuePairs = this.keyValues();
    let objString = `${valuePairs[0].toString()}`;
    for (let i = 1; i < valuePairs.length; i++) {
      objString = `${objString},${valuePairs[i].toString()}`;
    }
    return objString;
  }
}

散列表

请添加图片描述

class HashTable {
  constructor(toStrFn = defaultToString) {
    this.toStrFn = toStrFn;
    this.table = {};
  }
  // 创建散列函数
  loseloseHashCode(key) {
    if (typeof key === "number") {
      return key;
    }
    const tableKey = this.toStrFn(key);
    let hash = 0;
    for (let i = 0; i < tableKey.length; i++) {
      hash += tableKey.charCodeAt(i);
    }
    // 规避操作数超过数值变量最大表示范围的风险
    return hash % 37;
  }
  /* djb2HashCode(key) {
    const tableKey = this.toStrFn(key);
    let hash = 5381;
    for (let i = 0; i < tableKey.length; i++) {
      hash = (hash * 33) + tableKey.charCodeAt(i);
    }
    return hash % 1013;
  } */
  hashCode(key) {
    return this.loseloseHashCode(key);
  }
  // 将键和值加入散列表，向散列表增加一个新的项（也能更新散列表）
  put(key, value) {
    if (key != null && value != null) {
      const position = this.hashCode(key);
      this.table[position] = new ValuePair(key, value);
      return true;
    }
    return false;
  }
  get(key) {
    const valuePair = this.table[this.hashCode(key)];
    return valuePair == null ? undefined : valuePair.value;
  }
  // 从散列表中移除一个值
  remove(key) {
    const hash = this.hashCode(key);
    const valuePair = this.table[hash];
    if (valuePair != null) {
      delete this.table[hash];
      return true;
    }
    return false;
  }
  getTable() {
    return this.table;
  }
  isEmpty() {
    return this.size() === 0;
  }
  size() {
    return Object.keys(this.table).length;
  }
  clear() {
    this.table = {};
  }
  toString() {
    if (this.isEmpty()) {
      return "";
    }
    const keys = Object.keys(this.table);
    let objString = `{${keys[0]} => ${this.table[keys[0]].toString()}}`;
    for (let i = 1; i < keys.length; i++) {
      objString = `${objString},{${keys[i]} => ${this.table[
        keys[i]
      ].toString()}}`;
    }
    return objString;
  }
}
散列表和散列集合

有时候，一些键会有相同的散列值。不同的值在散列表中对应相同位置的时候，我们称其为冲突。处理冲突有几种方法：分离链接、线性探查和双散列法。分离链接法为散列表的每一个位置创建一个链表并将元素存储在里面。线性探查法处理冲突的方法是将元素直接存储到表中，而不是在单独的数据结构中，当想向表中某个位置添加一个新元素的时候，如果索引为 position 的位置已经被占据了，就尝试 position+1 的位置。如果 position+1 的位置也被占据了，就尝试 position+2 的位置，以此类推，直到在散列表中找到一个空闲的位置

分离链接法

请添加图片描述

// 使用分离链接法来处理冲突
class HashTableSeparateChaining {
  constructor(toStrFn = defaultToString) {
    this.toStrFn = toStrFn;
    this.table = {};
  }
  loseloseHashCode(key) {
    if (typeof key === "number") {
      return key;
    }
    const tableKey = this.toStrFn(key);
    let hash = 0;
    for (let i = 0; i < tableKey.length; i++) {
      hash += tableKey.charCodeAt(i);
    }
    return hash % 37;
  }
  hashCode(key) {
    return this.loseloseHashCode(key);
  }
  // 插入值
  put(key, value) {
    if (key != null && value != null) {
      const position = this.hashCode(key);
      if (this.table[position] == null) {
        this.table[position] = new LinkedList();
      }
      this.table[position].push(new ValuePair(key, value));
      return true;
    }
    return false;
  }
  // 获取给定键的值
  get(key) {
    const position = this.hashCode(key);
    const linkedList = this.table[position];
    if (linkedList != null && !linkedList.isEmpty()) {
      let current = linkedList.getHead();
      while (current != null) {
        if (current.element.key === key) {
          return current.element.value;
        }
        current = current.next;
      }
    }
    return undefined;
  }
  // 移除一个元素
  remove(key) {
    const position = this.hashCode(key);
    const linkedList = this.table[position];
    if (linkedList != null && !linkedList.isEmpty()) {
      let current = linkedList.getHead();
      while (current != null) {
        if (current.element.key === key) {
          linkedList.remove(current.element);
          if (linkedList.isEmpty()) {
            delete this.table[position];
          }
          return true;
        }
        current = current.next;
      }
    }
    return false;
  }
  isEmpty() {
    return this.size() === 0;
  }
  size() {
    let count = 0;
    Object.values(this.table).forEach((linkedList) => {
      count += linkedList.size();
    });
    return count;
  }
  clear() {
    this.table = {};
  }
  getTable() {
    return this.table;
  }
  toString() {
    if (this.isEmpty()) {
      return "";
    }
    const keys = Object.keys(this.table);
    let objString = `{${keys[0]} => ${this.table[keys[0]].toString()}}`;
    for (let i = 1; i < keys.length; i++) {
      objString = `${objString},{${keys[i]} => ${this.table[
        keys[i]
      ].toString()}}`;
    }
    return objString;
  }
}
线性探查法

请添加图片描述

线性探查技术分为两种：软删除和惰性删除

软删除

请添加图片描述

// 软删除
class HashTableLinearProbing {
  constructor(toStrFn = defaultToString) {
    this.toStrFn = toStrFn;
    this.table = {};
  }
  loseloseHashCode(key) {
    if (typeof key === "number") {
      return key;
    }
    const tableKey = this.toStrFn(key);
    let hash = 0;
    for (let i = 0; i < tableKey.length; i++) {
      hash += tableKey.charCodeAt(i);
    }
    return hash % 37;
  }
  hashCode(key) {
    return this.loseloseHashCode(key);
  }
  put(key, value) {
    if (key != null && value != null) {
      const position = this.hashCode(key);
      if (this.table[position] == null) {
        this.table[position] = new ValuePair(key, value);
      } else {
        let index = position + 1;
        while (this.table[index] != null) {
          index++;
        }
        this.table[index] = new ValuePair(key, value);
      }
      return true;
    }
    return false;
  }
  get(key) {
    const position = this.hashCode(key);
    if (this.table[position] != null) {
      if (this.table[position].key === key) {
        return this.table[position].value;
      }
      let index = position + 1;
      while (this.table[index] != null && this.table[index].key !== key) {
        index++;
      }
      if (this.table[index] != null && this.table[index].key === key) {
        return this.table[position].value;
      }
    }
    return undefined;
  }
  remove(key) {
    const position = this.hashCode(key);
    if (this.table[position] != null) {
      if (this.table[position].key === key) {
        delete this.table[position];
        this.verifyRemoveSideEffect(key, position);
        return true;
      }
      let index = position + 1;
      while (this.table[index] != null && this.table[index].key !== key) {
        index++;
      }
      if (this.table[index] != null && this.table[index].key === key) {
        delete this.table[index];
        this.verifyRemoveSideEffect(key, index);
        return true;
      }
    }
    return false;
  }
  verifyRemoveSideEffect(key, removedPosition) {
    const hash = this.hashCode(key);
    let index = removedPosition + 1;
    while (this.table[index] != null) {
      const posHash = this.hashCode(this.table[index].key);
      if (posHash <= hash || posHash <= removedPosition) {
        this.table[removedPosition] = this.table[index];
        delete this.table[index];
        removedPosition = index;
      }
      index++;
    }
  }
  isEmpty() {
    return this.size() === 0;
  }
  size() {
    return Object.keys(this.table).length;
  }
  clear() {
    this.table = {};
  }
  getTable() {
    return this.table;
  }
  toString() {
    if (this.isEmpty()) {
      return "";
    }
    const keys = Object.keys(this.table);
    let objString = `{${keys[0]} => ${this.table[keys[0]].toString()}}`;
    for (let i = 1; i < keys.length; i++) {
      objString = `${objString},{${keys[i]} => ${this.table[
        keys[i]
      ].toString()}}`;
    }
    return objString;
  }
}
惰性删除

请添加图片描述

// 惰性删除
class HashTableLinearProbingLazy {
  constructor(toStrFn = defaultToString) {
    this.toStrFn = toStrFn;
    this.table = {};
  }
  loseloseHashCode(key) {
    if (typeof key === "number") {
      return key;
    }
    const tableKey = this.toStrFn(key);
    let hash = 0;
    for (let i = 0; i < tableKey.length; i++) {
      hash += tableKey.charCodeAt(i);
    }
    return hash % 37;
  }
  hashCode(key) {
    return this.loseloseHashCode(key);
  }
  put(key, value) {
    if (key != null && value != null) {
      const position = this.hashCode(key);
      if (
        this.table[position] == null ||
        (this.table[position] != null && this.table[position].isDeleted)
      ) {
        this.table[position] = new ValuePairLazy(key, value);
      } else {
        let index = position + 1;
        while (this.table[index] != null && !this.table[position].isDeleted) {
          index++;
        }
        this.table[index] = new ValuePairLazy(key, value);
      }
      return true;
    }
    return false;
  }
  get(key) {
    const position = this.hashCode(key);
    if (this.table[position] != null) {
      if (this.table[position].key === key && !this.table[position].isDeleted) {
        return this.table[position].value;
      }
      let index = position + 1;
      while (
        this.table[index] != null &&
        (this.table[index].key !== key || this.table[index].isDeleted)
      ) {
        if (this.table[index].key === key && this.table[index].isDeleted) {
          return undefined;
        }
        index++;
      }
      if (
        this.table[index] != null &&
        this.table[index].key === key &&
        !this.table[index].isDeleted
      ) {
        return this.table[position].value;
      }
    }
    return undefined;
  }
  remove(key) {
    const position = this.hashCode(key);
    if (this.table[position] != null) {
      if (this.table[position].key === key && !this.table[position].isDeleted) {
        this.table[position].isDeleted = true;
        return true;
      }
      let index = position + 1;
      while (
        this.table[index] != null &&
        (this.table[index].key !== key || this.table[index].isDeleted)
      ) {
        index++;
      }
      if (
        this.table[index] != null &&
        this.table[index].key === key &&
        !this.table[index].isDeleted
      ) {
        this.table[index].isDeleted = true;
        return true;
      }
    }
    return false;
  }
  isEmpty() {
    return this.size() === 0;
  }
  size() {
    let count = 0;
    Object.values(this.table).forEach((valuePair) => {
      count += valuePair.isDeleted === true ? 0 : 1;
    });
    return count;
  }
  clear() {
    this.table = {};
  }
  getTable() {
    return this.table;
  }
  toString() {
    if (this.isEmpty()) {
      return "";
    }
    const keys = Object.keys(this.table);
    let objString = `{${keys[0]} => ${this.table[keys[0]].toString()}}`;
    for (let i = 1; i < keys.length; i++) {
      objString = `${objString},{${keys[i]} => ${this.table[
        keys[i]
      ].toString()}}`;
    }
    return objString;
  }
}

推荐使用 Map WeakMap

bestadc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字典和散列表
哈哩噜啾啾哈呀呀的博客
04-05 610
集合、字典和散列表可以存储不重复的值。在集合中，我们感兴趣的是每个值本身，并把它 当作主要元素。在字典中，我们用[键，值]的形式来存储数据。在散列表中也是一样（也是以[键， 值]对的形式来存储数据）。但是两种数据结构的实现方式略有不同 字典 字典和集合很相似，集合以[值，值]的形式存储元素，字 典则是以[键，值]的形式来存储元素。字典也称作映射。 实现一个字典类 function Dictiona...
散列表结构 字典与集合
weixin_34174322的博客
10-19 327
散列表结构 字典与集合 散列表 散列表(Hash Table)结构是字典(Dictionary)和集合(Set)的一种实现方式。散列算法的作用是尽可能快地在数据结构中找到一个值。在散列表上插入、删除和取用数据都非常快，但是对于查找操作来说却效率地下 散列表是基于数组进行设计的，数组的长度是预先设定，如有需要可随时增加。所有元素根据和该元...
散列表(字典)
chupengfei_hust的博客
01-16 525
文章目录问题散列函数应用案例将散列表用于查找防止重复将散列表用作缓存冲突性能装填因子良好的散列函数 问题 你在一家杂货店上班。有顾客来买东西时，你得在一个本子中查找价格。 如果本子的内容不是按字母顺序排列的，你可能为查找苹果（apple）的价格而浏览每一行，这需要很长的时间。使用的是简单查找，需要浏览每一行。时间复杂度为O(n)O(n)O(n)。 如果本子的内容是按字母顺序排列的，可使用二分查找来...
说说Python中字典和散列表，散列冲突的解决原理
python学习者的博客
06-14 1553
散列表 Python用散列表来实现dict。散列表其实是一个稀疏数组（总是有空白元素的数组称为稀疏数组）。在一般书中，散列表里的单元通常叫做表元（bucket）。在dict的散列表当中，每个键值对都占用一个表元，每个表元都有两个部分，一个是对键的引用，一个是对值的引用。因为每个表元的大小一致，所以可以通过偏移量来读取某个表元。 Python会设法保证大概还有三分之一的表元是空的，当快...
字典与散列表
xiaoding133的专栏【Stay hungry,Stay foolish】
08-21 3332
一、字典 字典（dictionary）是一些元素的集合。每个元素有一个称作key 的域，不同元素的key各 不相同。有关字典的操作有： • 插入具有给定关键字值的元素。 • 在字典中寻找具有给定关键字值的元素。 • 删除具有给定关键字值的元素。 随机访问：若仅按照一个字典元素本身的关键字来访问该元素。 顺序访问：指按照关键字的递增顺序逐个访问字典中的元素。顺序访问需借助于Be
Data-Stuctures-master.zip_data structure_processing
09-20
9. **散列表（字典）**：散列表是一种关联数组，通过键值对来存储数据，利用哈希函数快速查找和操作元素。 这些数据结构的选择和使用取决于具体的应用场景和性能需求。例如，如果需要快速查找，哈希表可能是最佳...
手稿_V1.087
08-03
散列表可以用来快速判断一个单词是否存在于字典中，因为它的查找时间复杂度可以达到O(1)。然而，对于前缀检查，散列表可能并不理想，因为它不支持前缀查询。相反，前缀树（Trie）是一种更为适合的数据结构。前缀树...
Ruby中的数组和散列表的使用详解
09-21
在Ruby编程语言中，数组（Arrays）和散列表（Hashes）是两种非常重要的数据结构，它们用于存储和管理对象的集合。数组以整数为索引，而散列表则使用任意对象作为键。这两者都是动态调整大小的，允许在需要时添加新的...
C++使用字典树，平衡树，散列表实现英汉字典源代码，数据结构课程设计
最新发布
03-02
基本要求：实现字典常用的数据结构包括有序表、AVL树、Patricia Tree（简称PAT tree，它是一棵压缩存储的二叉树结构）、散列表等，选一种数据结构，实现字典的基本操作，查找单词、插入单词（插入时，先查找，找不到...
201700130009_张愈博_实验81
08-08
实验中进行了线性开型散列表和链式散列表的建立、搜索和删除操作，并对结果进行了可视化展示。 【问题与解决方案】 1. 在`sortedChain`的`insert`操作中，由于`PairNode`的构造函数问题导致错误。解决办法是在`Pair...
数据结构—————散列表（哈希表）和字典(unity)
纸上得来终觉浅，绝知此事要躬行
09-25 1905
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(...
数据结构之字典和散列表
小栗子的博客
06-23 309
字典和散列表1. 字典2. 散列表 1. 字典 set(key, value) 向字典中添加新元素，如果key已经存在，原来的值会被覆盖。 remove(key) 删除字典中的元素。 get(key) 获取字典中的元素。 size() 获取元素个数。 hasKey(key) 是否包含某个键。 clear() 清空字典。 keys() 获取所有键。 values() 获取所有值。 keyValues() 返回所有[key, value]。 isEmpty() 字段是否为空。 forEach(callbac
字典的散列法表示。
LiYang2087的专栏
12-01 488
#include  #include  typedef int KeyType;typedef int DataType;typedef struct {    KeyType key;    DataType value;} DicElement;typedef struct {    int m;    DicElement 
流畅的python--字典中的散列表
Perror的博客
06-15 967
字典中的散列表其实就是稀疏数组（总会有一些元素是空白的数组），散列表中的单元叫：表元，在构建字典时会有产生两个表元，一个用来标记健，一个用来标记值，因为两个表元的长度都是相等的，所以可以通过表元的偏移量来查找字典。        python中最具有效率的内置数据类型就是字典和集合，这两种都是通过散列表来实现的。为了测试python中字典，集合和其他的数据类型的速度我做了以下的实验：import
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 字典 — 散列实现
coding-hwz
08-29 248
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 字典 — 散列实现一、散列表1、理想散列2、散列函数和散列表（1）桶和起始桶（2）除法散列函数（3）冲突和溢出（4）一个好的散列函数（5）除法和非整型关键字3、线性查找二、线性查找散列表实现 一、散列表 1、理想散列 字典的另一种表示方法是散列。它用一个散列函数把字典的数对映射到一个散列表的具体位置。如果数对 p 的关键字是 k，散列函数为 f，那么在理想情况下，p 在散列表中的位置为 f(k)。暂时假定散列表的每一个位置最多能够存储一个记录。为了
搞定数据结构：字典和散列（哈希表）
lydia的专栏lljstar.com
11-05 468
字典和散列是两种很重要的数据结构，C++里面的unordered_map使用哈希表做底层，但是要问这两种数据结构底层是什么样的，可能很多人回答不上来。
数据结构（十一）——散列和字典小结
夜的第七章
07-02 615
文章目录前言字典字典是如何和散列与跳表联系起来的呢？散列散列函数p这样选取的原因冲突与溢出处理冲突的方法散列性能分析散列实现 前言 看完散列和跳表的部分，最大的感受的就是已经开始摆脱基本的数据结构，比如栈和队列，代码的实现开始复杂起来。 这一部分引出了一个新的概念 —— 字典。 字典 字典： 字典由一些形如（k,v）的数对所组成的集合，其中k是关键字（key），v是与关键字k对应的值（value）。比如学号和你的一门成绩对应，key便是你的学号，value便是你的成绩。 字典是如何和散列与跳表联系起来的呢？
字典及散列表，字典用法
向宪章的博客
08-28 1118
字典和散列表 字典类型不但在各种程序里广泛使用，它也是Python语言的基石。模块的命名空间、实例的属性和函数的关键字参数中都可以看到字典的身影。跟它有关的内置函数都在__bulitins__.dict__模块中。 正是因为字典至关重要，Python对它实现了高度优化，而散列表则是字典类型性能出众的根本原因。 collections.abc模块中有Mapping和MutableMapping...
散列表：从理论到实践的艺术与科学
编程语言中的字典或映射类型，如Python的dict和JavaScript的对象，其底层实现就基于散列表。 散列表是计算机科学中极其重要的一种数据结构，它结合了数学和计算机科学的艺术与科学，使得数据的存储和检索变得高效。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值