求解，数据结构与算法

关键字序列是{19,13,33,02,16,24,7},计算过程如下:

插入关键字19, 索引(哈希值) = 19 mod 11 = 8, 存入哈希表:

  下标    0   1   2   3   4   5   6   7   8   9   10
  关键字                                 19

插入关键字13, 索引(哈希值) = 13 mod 11 = 2, 存入哈希表:
 
  下标    0   1   2   3   4   5   6   7   8   9   10
  关键字         13                      19

插入关键字33, 索引(哈希值) = 33 mod 11 = 0, 存入哈希表:

  下标    0   1   2   3   4   5   6   7   8   9   10
  关键字 33      13                      19

插入关键字02, 索引(哈希值) = 02 mod 11 = 2, 有冲突,取新索引2+1=3,没有冲突,存入哈希表:

  下标    0   1   2   3   4   5   6   7   8   9   10
  关键字 33      13   2                  19

插入关键字16, 索引(哈希值) = 16 mod 11 = 5, 存入哈希表:

  下标    0   1   2   3   4   5   6   7   8   9   10
  关键字 33      13   2      16          19

插入关键字24, 索引(哈希值) = 24 mod 11 = 2, 有冲突,取索引2+1=3,仍有冲突,
再取索引3+1=4,没有冲突,存入哈希表:

  下标    0   1   2   3   4   5   6   7   8   9   10
  关键字 33      13   2  24  16          19

插入关键字7, 索引(哈希值) = 7 mod 11 = 7, 存入哈希表:

  下标    0   1   2   3   4   5   6   7   8   9   10
  关键字 33      13   2  24  16       7  19

这就是最后得到的哈希表.


//C语言测试程序
#include<stdio.h>
#include<stdlib.h>

#define SUCCESS 1
#define UNSUCCESS 0
#define HASHSIZE 11
#define NULLKEY -1
typedef int Status;

typedef struct
{
    int *elem;
    int count;
}HashTable;

int m=0;

Status InitHashTable(HashTable *H)
{
    int i;
    m=HASHSIZE;
    H->count=m;
    H->elem=(int *)malloc(m*sizeof(int));
    for(i=0;i<m;i++)
    {
        H->elem[i]=NULLKEY;
    }
    return SUCCESS;
}

int Hash(int key)
{
    return key % m;
}

void InsertHash(HashTable *H,int key)
{
    int addr;
    int pos;
    pos=Hash(key);
    addr=pos;
    while(H->elem[addr] != NULLKEY)
    {
        ////////
        printf("索引=%d 有冲突.\n",addr);
        ////////
        addr = (addr+1) % m;
        if(addr==pos)
        {
            printf("\n散列表已满!\n");
            exit(1);
        }
    }
    H->elem[addr]=key;
}

Status SearchHash(HashTable H,int key,int *addr)
{
    *addr = Hash(key);
    while(H.elem[*addr] != key)
    {
        *addr = (*addr+1) % m;
        if(H.elem[*addr]==NULLKEY || *addr==Hash(key))
        {
            return UNSUCCESS;
        }
    }
    return SUCCESS;
}

void showHashTable(HashTable *H)
{
    int i;
    for(i=0 ; i < H->count ;i++)
    {
        printf("%4d",i);
    }
    printf("\n");
    for(i=0 ; i < H->count ;i++)
    {
        if(H->elem[i]==NULLKEY)
        {
            printf("%4c",0x20);
        }
        else
        {
            printf("%4d",H->elem[i]);
        }
    }
    printf("\n");
}

int main()
{
    int key[]={19,13,33,02,16,24,7}; 

    int len;
    int i;
    HashTable H;

    InitHashTable(&H);

    len=sizeof(key)/sizeof(key[0]);
    for(i=0;i<len;i++)
    {
        printf("插入 %d, 索引(Hash) = %d\n",key[i],Hash(key[i]));
        InsertHash(&H,key[i]);
        showHashTable(&H);
    }

return 0;
}