《Cracking the Coding Interview》——第8章：面向对象设计——题目10

2014-04-24 00:05

题目：用拉链法设计一个哈希表。

解法：一个简单的哈希表，就看成一个数组就好了，每个元素是一个桶，用来放入元素。当有多个元素落入同一个桶的时候，就用链表把它们连起来。由元素值到哈希值的映射就是哈希函数了。

代码：

 // 8.10 Design a hash table. Handle conflicts with chaining(linked lists).
 #include <iostream>
 #include <string>
 #include <vector>
 using namespace std;

 class HashMap {
 public:
     HashMap() {
         _buckets.resize(_bucket_num);
         int i;

         for (i = ; i < _bucket_num; ++i) {
             _buckets[i] = nullptr;
         }
     };

     bool contains(int key) {
         key = (key > ) ? key : -key;
         key = key % _bucket_num;
         LinkedList *ptr = _buckets[key];

         while (ptr != nullptr) {
             if (ptr->key == key) {
                 return true;
             }
         }

         return false;
     };

     int& operator [] (int key) {
         key = (key > ) ? key : -key;
         key = key % _bucket_num;
         LinkedList *ptr = _buckets[key];

         if (ptr == nullptr) {
             _buckets[key] = new LinkedList(key);
             return _buckets[key]->val;
         }

         LinkedList *ptr2 = ptr->next;
         if (ptr->key == key) {
             return ptr->val;
         }

         while (ptr2 != nullptr) {
             if (ptr2->key == key) {
                 return ptr2->val;
             } else {
                 ptr = ptr->next;
                 ptr2 = ptr2->next;
             }
         }
         ptr->next = new LinkedList(key);
         ptr = ptr->next;
         return ptr->val;
     }

     void erase(int key) {
         key = (key > ) ? key : -key;
         key = key % _bucket_num;
         LinkedList *ptr = _buckets[key];

         if (ptr == nullptr) {
             return;
         } else if (ptr->next == nullptr) {
             if (ptr->key == key) {
                 delete _buckets[key];
                 _buckets[key] = nullptr;
             }
             return;
         }

         if (ptr->key == key) {
             _buckets[key] = ptr->next;
             delete ptr;
             return;
         }

         LinkedList *ptr2;
         ptr2 = ptr->next;

         while (ptr2 != nullptr) {
             if (ptr2->key == key) {
                 ptr->next = ptr2->next;
                 delete ptr2;
                 return;
             } else {
                 ptr = ptr->next;
                 ptr2 = ptr2->next;
             }
         }
     }

     ~HashMap() {
         int i;
         LinkedList *ptr;

         for (i = ; i < _bucket_num; ++i) {
             ptr = _buckets[i];
             while (ptr != nullptr) {
                 ptr = ptr->next;
                 delete _buckets[i];
                 _buckets[i] = ptr;
             }
         }
         _buckets.clear();
     }
 private:
     struct LinkedList {
         int key;
         int val;
         LinkedList *next;
         LinkedList(int _key = , int _val = ): key(_key), val(_val), next(nullptr) {};
     };

     static const int _bucket_num = ;
     vector<LinkedList *> _buckets;
 };

 int main()
 {
     HashMap hm;
     string cmd;
     int op1, op2;

     while (cin >> cmd) {
         if (cmd == "set") {
             cin >> op1 >> op2;
             hm[op1] = op2;
         } else if (cmd == "get") {
             cin >> op1;
             cout << hm[op1] << endl;
         } else if (cmd == "find") {
             cin >> op1;
             cout << (hm.contains(op1) ? "true" : "false") << endl;
         }
     }

     return ;
 }