swift 字典添加元素 js 字典添加元素

集合以[值，值]的形式存储元素，而字典和散列表以[键，值]的形式存储元素

一、字典

创建字典

function Dictionary() {
    var items = {};

    /*has(key)如果某个键值存在于这个字典中，则返回true*/
    this.has = function(key) {
        return key in items;
    };

    /*set(key, value)向字典添加新元素*/
    this.set = function(key, value) {
        items[key] = value;
    };

    /*remove(key)从字典中移除键值对应的数据*/
    this.remove = function(key) {
        if (this.has(key)) {
            delete items[key];
            return true;
        }
        return false;
    };

    /*get(key)通过键值查找特定的数值并返回*/
    this.get = function(key) {
        return this.has(key) ? items[key] : undefined;
    };

    /*values()将字典所包含的所有数值以数组的形式返回*/
    this.values = function() {
        var values = [];
        for (var k in items) {  //包含了对象原型中的属性
            if (this.has(k)) {  //过滤掉对象原型中的属性
                values.push(items[k]);
            }
        }
        return values;
    };

    /*clear(), size, keys, getItems*/
    this.clear = function() {
        items = {};
    };
    this.size  = function() {
        return Object.keys(items).length;
    };
    this.keys = function() {
        return Object.keys(items);  //Object.keys()返回一个包含对象所有属性的数组
    };
    this.getItems = function() {
        return items;
    };
}

二、散列表

不是遍历键值来找到匹配的值，而是将每个属性转化为一个索引，通过数组的形式，检索到想要的值

创建散列表

先创建一个散列函数：给定key参数，就能够根据组成key的每个字符的ASCII码值的和得到一个数字

function HashTable() {
    var table = [];

    /*散列函数*/
    var loseloseHashCode = function(key) {
        var hash = 0;
        for (var i = 0; i < key.length; i++) {
            hash += key.charCodeAt(i);
        }
        return hash % 37;
    };

    /*添加、获取和移除等方法*/
    this.put = function(key, value) {
        var position = loseloseHashCode(key);
        console.log(position + '-' + key);  //可移除
        table[position] = value;
    };
    this.get = function(key) {
        return table[loseloseHashCode(key)];
    };
    this.remove = function(key) {
        table[loseloseHashCode(key)] = undefined;
    };
}

散列表中的冲突

当添加多个键值时，有一些键会有相同的散列值

var hash = new HashTable();

hash.put('Gandalf', '[e-mail]');
hash.put('John', '[e-mail]');
hash.put('Tyrion', '[e-mail]');
hash.put('Aaron', '[e-mail]');
hash.put('Donnie', '[e-mail]');
hash.put('Ana', '[e-mail]');
hash.put('Jonathan', '[e-mail]');
hash.put('Jamie', '[e-mail]');
hash.put('Sue', '[e-mail]');
hash.put('Mindy', '[e-mail]');
hash.put('Paul', '[e-mail]');
hash.put('Nathan', '[e-mail]');

依次出现在控制台的结果是：

19-Gandalf
29-John
16-Tyrion
16-Aaron
13-Donnie
13-Ana
5-Jonathan
5-Jamie
5-Sue
32-Mindy
32-Paul
10-Nathan

先添加一个print()辅助方法，在控制台中输出HashTable中的值。

遍历数组中的所有元素，当某个位置上有值的时候，在控制台输出位置和对应的值

this.print = function() {
    for (var i = 0; i < table.length; i++) {
        if (table[i] !== undefined) {
            console.log(i + ":" + table[i]);
        }
    }
};

使用print()方法

hash.print();

控制台结果：

5:[e-mail]
10:[e-mail]
13:[e-mail]
16:[e-mail]
19:[e-mail]
29:[e-mail]
32:[e-mail]

相同的位置，后添加的值将前面的值覆盖掉了

处理散列表中的冲突

1.分离链接法

首先在HashTable类内部添加一个新的辅助类，表示将要加入LinkedList实例的元素，此类将key和value存储在一个Object实例中

var ValuePair = function(key, value) {
    this.key = key;
    this.value = value;
    this.toString = function() {
        return '[' + this.key + '-' + this.value + ']';
    };
};

重写put()方法，首先验证加入的新元素的位置是否已经被占据。如果没有，则在此位置初始化一个LinkedList类的实例；如果有则使用append()方法，向LinkedList实例中添加一个ValuePair实例

this.put = function(key, value) {
    var position = loseloseHashCode(key);
    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 false;
};

---

未完待续~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

2.线性探查

创建更好的散列函数