散列 简单实现（学习笔记）

散列简介

散列是一种用于以常数平均时间进行插入、删除、查找的技术；但是，那些需要元素间任何排序信息的操作将
不会得到有效的支持，比如FindMax/FindMin以及以线性时间按
排序顺序将整个表进行打印的操作都是散列表所不支持的；
对散列表的理解：
    我们查找东西时一种做法是将东西标号，然后二分查找(二叉树)，另一种做法是将东西分类，即哈希。
一个理想的散列表数据结构只不过是一个包含有关键字的具有固定大小的数组。每个关键字被映射到数组0-N-1这
个范围中的某一个数，并且被放到适当的单元里。这个映射就叫做*散列函数*；最理想的情况下是保证任何两个不
同关键字被映射到不同的单元里。不过这是不可能的，因为单元的
数目是有限的，而关键字是无限的。因此，需要一个散列函数，
他能在单元之间均匀的分配关键字；剩下的问题就是解决当亮哥关键字散列到同一个值的时候应该怎么做了——
解决冲突；
一个较好的散列函数:

int Hash(const char* key, int TableSize)
{
    unsigned int HashVal = 0;
    while(*key != '\0')
        HashVal = (HashVal << 5) + *key++;
    return HashVal % TableSize;
}

解决冲突的方法：
有分离链接法，开发定址法等；我觉得分离链接法比较好理解，下面代码都采用分离链接法；

分离链接散列表的类型声明

// 链表节点声明
struct ListNode;
typedef struct *ListNode Position;
struct ListNode
{
    int Element;
    Position Next;
};
// 哈希表结构定义
typedef Position List; // 这些typedef主要是为了便于理解以及简化书写
struct HashTbl;
typedef struct *HashTbl HashTable;
struct HashTbl
{
    int TableSize;   // 哈希表的长度
    // 指向 “指向ListNode结构的指针” 的指针 ，
    // 有些实现里直接指定了 TableList的大小 如List TableList[10]这种，这采用动态分配
    List *TableList; 
};

分离链接散列表初始化例程

HashTable InitTable(int TableSize)
{
    HashTable H = NULL;
    int i = 0;

    H = malloc(sizeof(struct HashTbl));
    if(NULL == H) return NULL;

    H->TableSize = TableSize;
    // 给散列表分配空间
    // 注意这里 不是 sizeof(struct ListNode), 实际是申请了TableSize个数组，里边元素是List（指
    针）即指针数组
    H->TableList = malloc(sizeof(List) * H->TableSize);
    if(NULL == H->TableList) return NULL;

    // 这里List的实现加了个表头，所以要为每个表头分配内存
    for(i; i < H->TableSize; ++i)
    {
        // 注意，这里才是 sizeof(struct ListNode)
        H->TableList[i] = malloc(sizeof(struct ListNode));
        if(NULL == H->TableList[i])
            return NULL;
        else
            H->TableList[i]->Next = NULL;
    }
    return H;   
}

分离连接散列表的Find例程

Position Find(HashTable H, ElementType key)
{
    Position P = NULL;
    List L = NULL;
    if(NULL == H) return NULL;
    // 首先找到key对应的表头，因为一维是个数组，所以可以根据下标来找
    L = H->TableList[ Hash(key, H->TableSize) ];    
    if(NULL == L) return NULL;
    // 掠过表头
    P= L->Next;
    // 遍历链表
    while(P != NULL && P->Element != key)
        P = P->Next;
    reutrn P;
}

分离连接散列表的Insert例程

void Insert(HashTable H, ElementType key)
{
    if(NULL == H) return;

    // 首先查找，如果不存在则插入插入插入....哈哈
    Position Pos, NewCell;

    Pos = Find(H, key);
    if(NULL == Pos)
    {
        NewCell = malloc(sizeof(struct ListNode));
        if(NULL == NewCell) return;
        // 找到key对应的表头
        List L = H->TableList[ Hash(key, H->TableSize) ];
        // 这里采用头部插入
        NewCell->Next = L->Next;
        NewCell->Element = key; // 可能需要拷贝
        L->Next = NewCell; 
    }
}

// 插入例程有要改进的地方，因为每次插入都要查找一次，即两次遍历，暂时先这样；