散列表

如果表够大，散列函数足够好，那么散列表在查找上具有O(1)的时间复杂度。

但是我们考虑出现冲突的情况，如果使用分离链表法来处理冲突。那么链表的平均长度等于装填因子a（元素个数与散列表大小的比值）的大小。所以不成功查找的复杂度为a，成功查找的复杂度为1 + a/2。

代码实现如下：

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
// 分离链接散列表 
typedef unsigned int index;
typedef int itemType;
typedef struct ListNode *position;
typedef position list;
typedef struct HashTable *hashTable;

struct ListNode {
    itemType item;
    position next;
};
struct HashTable {
    int tableSize;
    list *listArr;
};

int
NextPrime(int n)
{
    int ceiling, isPrime;
    
    isPrime = 0;
    ceiling = 2 * n;
    
    for ( ; n < ceiling; n++) {
        int nSqrt = (int)sqrt(n);
        isPrime = 1;
        for (int i = 2; isPrime && i <= nSqrt; i++)
        {
            if (n % i == 0) {
                isPrime = 0;
            }  
        }
        if (isPrime) {
            return n;
        }
    }
}

index
Hash(itemType key, int tableSize)
{
    return key % tableSize;
}

hashTable
InitializeTable(int tableSize)
{
    hashTable h;
    
    h = (hashTable)malloc(sizeof(struct HashTable));
    if (h == NULL) {
        printf("Out of space!\n");
        exit(-1);
    }
    
    h->tableSize = NextPrime(tableSize);
    
    h->listArr = (list*)malloc(sizeof(list) * h->tableSize);
    //
    if (h->listArr == NULL) {
        printf("Out of space!\n");
        exit(-1);
    }
    
    memset(h->listArr, 0, h->tableSize * sizeof(list*));
    
    return h;
}

position
Find(itemType key, hashTable h)
{
    list l;
    
    l = h->listArr[Hash(key, h->tableSize)];
    
    for ( ; l != NULL; l = l->next) {
        //printf("%d\n", Hash(key, h->tableSize));
        if (l->item == key) {
            //printf("here\n");
            return l;
        }
    }
    
    return NULL;
}

void
Insert(itemType key, hashTable h)
{
    position p, newNode;
    list l;
    
    p = Find(key, h);
    
    int hValue = Hash(key, h->tableSize);
    
    if (p == NULL) {
        newNode = (position)malloc(sizeof(struct ListNode));
        if (newNode == NULL) {
            printf("Out of space!\n");
            exit(-1);
        }
        /* 错误的方法，只改变了 l 这个指针，却没变动listArr[hValue]本身。 
        list l = h->listArr[hValue];
        newNode->next = l;
        newNode->item = key;
        l = newNode;
        //h->listArr[hValue] = newNode;
        */
        
        newNode->item = key;
        newNode->next = h->listArr[hValue];
        h->listArr[hValue] = newNode;
        printf("key %d inserted at position %d.\n", h->listArr[hValue]->item, Hash(key, h->tableSize));
        
    }
}

int
main(int argc, char** argv)
{
    hashTable h;
    
    h = InitializeTable(10);
    
    for (int i = 0; i < 10; i++) {
        Insert(i*i, h);
    }
        
    
    for (int i = 0; i < 100; i++) {
        if (Find(i, h)) {
            printf("key: %d found.\n", i);
        } else {
            printf("key: %d not found.\n", i);
        }
    }
    
    
    system("pause");
    return 0;
}

-

另外，当我们使用开放定址法来处理冲突的时候，特别要注意删除的时候，不能直接删除。原因是如果你删除了P这个位置的元素x。那么如果以前有的元素y应该映射到P，却因为冲突而到了其他地方。当x被删除之后，P这个位置为空。那么如果我们要寻找y，就会第一个找到P这个位置，发现为空。于是就找不到y了。（可以继续遍历开放定址法的位置来寻找y……但是这样子不是太楞了吗？如果原本就没y这个元素呢，那我们得做许多无用功。）

不能直接删除，所以一般我们使用懒惰删除，给P位置一个“已删除”的标记，就能解决这个问题了。