JavaScript数据结构——集合、字典和散列表

集合、字典和散列表都可以存储不重复的值。

在集合中，我们感兴趣的是每个值本身，并把它当作主要元素。在字典和散列表中，我们用 [键，值] 的形式来存储数据。

集合（Set 类）：[值，值]对，是一组由无序且唯一（即不能重复）的项组成的。

字典（Map 类）：[键，值]对，也称作映射，其中键名是用来查询特定元素的。

散列（HashTable类/HashMap 类）：[键，值]对，是Dictionary类的一种散列表实现方式。散列函数的作用是给定一个键值，然后返回值在表中的地址。散列算法的作用是尽可能快地在数据结构中找到一个值。

在一些编程语言中，还有一种叫作散列集合的实现。散列集合由一个集合构成，但是插入、移除或获取元素时，使用的是散列函数。实现散列集合的不同之处在于，不再添加键值对，而是只插入值而没有键。和集合相似，散列集合只存储唯一的不重复的值。

--------------------------------------------------------------------------

（1）集合方法声明：

首先，使用对象来表示集合。

序号	方法	说明
1	add(value)	向集合添加一个新的项
2	remove(value)	从集合移除一个值
3	has(value)	如果值在结合中，返回 true，否则返回 false
4	clear ( )	移除集合中的所有项
5	size ( )	返回集合所包含元素的数量。与数组的 length 属性类似。
6	values ( )	返回一个包含集合中所有值的数组。

集合的实现：

 function Set() {
     var items = {};

     /*this.has = function(value) {
         return value in items;    // in 操作符会在通过对象访问给定属性时返回true，无论该属性存在于实例中还是原型中
     }*/

     // better way
     this.has = function(value) {
         return items.hasOwnProperty(value);    // hasOwnProperty()方法只在给定属性存在于对象实例中时，才会返回true
     };

     this.add = function(value) {
         if (!this.has(value)) {
             items[value] = value;    //添加一个值的时候，把它同时作为键和值保存，因为这样有利于查找这个值
             reutrn true;    // 返回true，表示添加了这个值
         }
         return false;    // 返回false，表示没有添加它
     };

     this.remove = function(value) {
         if (this.has(value)) {
             delete items[value];    // 既然用对象来存储集合的items对象，就可以简单地使用delete操作符从items对象中移除属性
             return true;
         }
         return false;
     };

     this.clear = function() {
         items = {};
     };

     // size实现方法一(只能在现代浏览器中运行)
     /*this.size = function() {
         return Object.keys(items).length;    // Object类有一个keys方法，返回一个包含给定对象所有属性的数组
     }*/

     // size实现方法二(可以在任何浏览器上运行)
     this.size = function() {
         var count = 0;
         for (var prop in items) {    // for...in...用于枚举对象中的属性，包括实例和原型中的属性
             if (items.hasOwnProperty(prop)) {    // 检查它们是否是对象自身的属性
                 ++count;
             }
         }
         return count;
     };

     // values实现方法一，同size实现方法一
     /*this.values = function() {
         return Object.keys(items);
     }*/

     // values实现方法二，同size实现方法二
     this.values = function() {
         var keys = [];
         for (var key in items) {
             keys.push(key);
         }
         return keys;
     };
 }

Set.js

（2）字典方法声明：

首先，使用对象来表示集合。

序号	方法	说明
1	set(key, value)	向字典中添加新元素
2	remove(key)	通过使用键值来从字典中移除键值对应的数据值
3	has(key)	如果某个键值存在于这个字典中，则返回 true，反之则返回 false
4	get(key)	通过键值查找特定的数值并返回
5	clear ( )	将这个字典中的所有元素全部删除
6	size ( )	返回字典中所包含元素的数量。与数组的 length 属性类似。
7	keys()	将字典所包含的所有键名以数组形式返回
8	values ( )	将字典所包含的所有数值以数组形式返回

字典的实现：

 function Dictionary() {
     var items = {};

     this.has = function(value) {    // 之所以要先实现该方法，是因为它会被set和remove等其他方法调用
         return key in items;
     };

     this.set = function(key, value) {
         items[key] = value;
     };

     this.remove = function(key) {
         if (this.has(key)) {
             delete items[key];
             return true;
         }
         return false;
     };

     this.get = function(key) {
         return this.has(key) ? items[key] : undefined;    // get方法会首先验证我们想要的值是否存在(通过查找key值)
     };

     this.values = function() {
         var values = [];
         for (var k in items) {
             if (this.has(k)) {
                 values.push(items[k]);
             }
         }
         return values;
     };

     this.clear = function() {
         items = {};
     };

     this.size = function() {
         return Object.keys(items).length;    // Object类有一个keys方法，返回一个包含给定对象所有属性的数组
     };

     this.keys = function() {
         return Object.keys(items);
     };

     this.getItems = function() {
         reutrn items;
     };
 }

Dictionary.js

（3）散列方法声明：

首先，使用数组来表示集合。

三个基础方法：

序号	方法	说明
1	put(key, value)	向散列表增加一个新的项（也能更新散列表）
2	remove(key)	根据键值从散列表中移除值
3	get(key)	返回根据键值检索到的特定的值

在实现这三个方法之前，要实现的第一个方法是散列函数，它是 HashTable 类中的一个私有方法。

处理散列表的冲突：

有时候，一些键会有相同的散列值。不同的值在散列表中对应相同位置的时候，我们称其为冲突。处理冲突有几种方法：分离链接、线性探查和双散列法。

分离链接：包括为散列表的每一个位置创建一个链表并将元素存储在里面。它是是解决冲突的最简单的方法，但是它在 HashTable 实例之外还需要额外的存储空间。

线性探查：当想向表中某个位置加入一个新元素的时候，如果索引为 index 的位置已经被占据了，就尝试 index+1 的位置。如果 index+1 的位置也被占据了，就尝试 index+2 的位置，以此类推。

一个表现良好的散列函数是由几个方面构成的：插入和检索元素的时间（即性能），当然也包括较低的冲突的可能。

散列表的实现：

 function HashTable() {
     var table = [];

     // 散列函数，是HashTable中的一个私有方法
     var loseloseHashCode = function(key) {
         var hash = 0;
         for (var i=0; i<key.length; i++) {
             hash += key.charCodeAt(i);    // 给定一个key参数，我们就能根据组成key的每个字符的ASCII码值的和得到一个数字
         }
         return hash % 37;    // 为了得到比较小的数值，我们会使用hash值和一个任意数做除法的余数
     };

     // 更好的散列函数(这并不是最好的散列函数，但这是最被社区推荐的散列函数之一)
     var djb2HashCode = function(key) {
         var hash = 5381;    // 初始化赋值为一个质数，大多数实现都使用5318
         for (var i=0; i<key.length; i++) {
             hash += hash * 33 + key.charCodeAt(i);    // 将hash与33相乘，当作一个魔力数
         }
         return hash % 1013;    // 将相加的和与另一个随机质数相除
     }

     this.put = function(key, value) {
         var position = loseloseHashCode(key);    // 给定一个键值，我们需要根据所创建的散列函数计算出它在表中的位置
         table[position] = value;    // 将value参数添加到用散列函数计算出的对应的位置上
     };

     this.get = function(key) {
         return table[loseloseHashCode(key)];    //loseloseHashCode(key)会返回值的位置
     };

     this.remove = function(key) {
         table[loseloseHashCode(key)] = undefined;
     };

     /*解决冲突方法一：分离链接*/

     // 为了实现一个使用了分离链接的HashTable实例，我们需要一个新的辅助类来表示将要加入LinkedList实例的元素
     var ValuePair = function(key, value) {
         this.key = key;
         this.value = value;
     }

     // 分离链接：重写put方法
     this.put = function(key, value) {
         var position = loseloseHashCode(key);
         // 如果这个位置是第一次被加入元素，我们会在这个位置上初始化一个LinkedList类的实例
         if (table[position] == undefined) {
             table[position] = new LinkedList();
         }
         table[position].append(new ValuePair(key, value));
     }

     // 分离链接：重写get方法
     this.get = function(key) {
         var position = loseloseHashCode(key);

         if (table[position] !== undefined) {

             //遍历链表来寻找键/值
             var current = table[position].getHead();

             while (current.next) {
                 if (current.element.key === key) {
                     return current.element.value;
                 }
                 current = current.next;
             }

             // 检查元素在链表第一个或最后一个节点的情况
             if (current.element.key === key) {
                 return current.element.value;
             }
         }
         return undefined;
     }

     // 分离链接：重写remove方法
     this.remove = function(key) {
         var position = loseloseHashCode(key);

         if (table[position] !== undefined) {

             var current = table[position].getHead();
             while (current.next) {
                 if (current.element.key === key) {
                     table[position].remove(current.element);
                     if (table[position].isEmpty()) {
                         table[position] = undefined;
                     }
                     return true;
                 }
                 current = current.next;
             }

             // 检查是否为第一个或最后一个元素
             if (current.element.key === key) {
                 table[position].remove(current.element);
                 if (table[position].isEmpty()) {
                     table[position] = undefined;
                 }
                 return true;    // 返回true表示这个元素已经被移除
             }
         }

         return false;    // 返回false表示这个元素在散列表中不存在
     }

     /*解决冲突方法二：线性探查*/
     var ValuePair = function(key, value) {
         this.key = key;
         this.value = value;
     }

     // 线性探查：重写put方法
     this.put = function(key, value) {
         var position = loseloseHashCode(key);

         if (table[position] == undefined) {
             table[position] = new ValuePair(key, value);
         } else {
             var index = ++position;
             while (table[index] != undefined) {
                 index++;
             }
             table[index] = new ValuePair(key, value);
         }
     }

     // 线性探查：重写get方法
     this.get = function(key) {
         var position = loseloseHashCode(key);

         if (table[position] !== undefined) {
             if (table[position].key === key) {
                 return table[position].value;
             } else {
                 var index = ++position;
                 while (table[index] === undefined || table[index].key !== key) {
                     index++;
                 }
                 if (table[index].key === key) {    //只是为了确认一下
                     return table[index].value;
                 }
             }
         }
         return undefined;
     }

     // 分离链接：重写remove方法
     this.remove = function(key) {
         var position = loseloseHashCode(key);

         if (table[position] !== undefined) {
             if (table[position].key === key) {
                 table[index] = undefined;
             } else {
                 var index = ++position;
                 while (table[index] === undefined || table[index].key !== key) {
                     index++;
                 }
                 if (table[index].key === key) {    //只是为了确认一下
                     table[index] = undefined;
                 }
             }
         }
         return undefined;
     }
 }

 HashTable.js

HashTable.js

参考书籍：《学习JavaScript数据结构与算法》