Anyview | 可调试的编程作业平台

【题目】假设哈希表长为m，哈希函数为H(x)，用链地址法处理冲突。试编写输入一组关键字并建造哈希表的算法。

哈希表的类型ChainHashTab定义如下：
#define NUM         7
#define NULLKEY    -1
#define SUCCESS     1
#define UNSUCCESS   0
#define DUPLICATE  -1

typedef char HKeyType;

typedef struct HNode {
   HKeyType  data;
   struct HNode*  next;
}*HLink;

typedef struct {
   HLink  *rcd;   // 指针存储基址，动态分配数组
   int    count;  // 当前表中含有的记录个数
   int    size;  // 哈希表的当前容量
}ChainHashTab;    // 链地址哈希表


/*以下函数可以直接调用*/
int Hash(ChainHashTab H, HKeyType k) { // 哈希函数
  return k % H.size;
}

Status Collision(ChainHashTab H, HLink &p) {
  // 求得下一个探查地址p 
  if (p && p->next) { 
    p = p->next;
    return SUCCESS;
  } else return UNSUCCESS;
}

实现下列函数：
int BuildHashTab(ChainHashTab &H, int n, HKeyType es[]);
/* 下列函数可以直接调用                             */
/* 哈希函数：                                   */
/*    int Hash(ChainHashTab H, HKeyType k);     */
/* 冲突处理函数：                               */
/*    int Collision(ChainHashTab H, HLink &p);  */

未通过测试数据

    H.count++;  // 更新记录个数
    return SUCCESS;  
    newNode->next = H.rcd[index];
    H.rcd[index] = newNode;  // 插入链表头
    int index = Hash(H, key);  // 计算哈希值
    HLink newNode = (HLink)malloc(sizeof(struct HNode));
    newNode->data = key;
    }
    if (search(H, key)) {
        return DUPLICATE;  // 如果已存在，返回重复
// 插入函数
int insert(ChainHashTab &H, HKeyType key) {
        p = p->next;
    }
    return 0;  // 未找到关键字
}
            return 1;  // 找到关键字
        }
    HLink p = H.rcd[index];
    while (p) {
        if (p->data == key) {
int search(ChainHashTab H, HKeyType key) {
    int index = Hash(H, key);  // 计算哈希值
// 搜索函数
#include "allinclude.h"  //DO NOT edit this line

输出窗口

编译中 14: 57: 35 编译通过 14: 57: 36 函数输入的关键字序列（即参数es[]）： Y X F I N I V H R X
正确结果：
0 : F
1 : N
2 : HV
3 : I
4 : X
5 : RY
6 :

你的结果：
0 : F
1 : N
2 :
3 : I
4 : X
5 : Y
6 :

--------ERROR--------
函数输入的关键字序列（即参数es[]）： L L X X Z K K Z K X T A Y
正确结果：
0 : T
1 :
2 : A
3 :
4 : X
5 : YK
6 : ZL

你的结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 : L

--------ERROR--------

开启调试成功 14: 57: 37 调试已关闭 14: 57: 39 编译通过 14: 58: 40 函数输入的关键字序列（即参数es[]）： Y X F I N I V H R X
正确结果：
0 : F
1 : N
2 : HV
3 : I
4 : X
5 : RY
6 :

开启调试成功 14: 58: 40 你的结果：
0 : F
1 : N
2 :
3 : I
4 : X
5 : Y
6 :

--------ERROR--------
函数输入的关键字序列（即参数es[]）： L L X X Z K K Z K X T A Y
正确结果：
0 : T
1 :
2 : A
3 :
4 : X
5 : YK
6 : ZL

调试已关闭 15: 00: 40 编译通过 15: 00: 43 函数输入的关键字序列（即参数es[]）： Y X F I N I V H R X
正确结果：
0 : F
1 : N
2 : HV
3 : I
4 : X
5 : RY
6 :

你的结果：
0 : F
1 : N
2 : HV
3 : II
4 : XX
5 : RY
6 :

--------ERROR--------
函数输入的关键字序列（即参数es[]）： L L X X Z K K Z K X T A Y
正确结果：
0 : T
1 :
2 : A
3 :
4 : X
5 : YK
6 : ZL

你的结果：
0 : T
1 :
2 : A
3 :
4 : XXX
5 : YKKK
6 : ZZLL

--------ERROR--------

运行完毕 15: 00: 44 题目未通过 15: 00: 44 编译通过 15: 03: 41 函数输入的关键字序列（即参数es[]）： Y X F I N I V H R X
正确结果：
0 : F
1 : N
2 : HV
3 : I
4 : X
5 : RY
6 :

你的结果：
0 : F
1 : N
2 : HV
3 : I
4 : X
5 : RY
6 :

========RIGHT========
函数输入的关键字序列（即参数es[]）： L L X X Z K K Z K X T A Y
正确结果：
0 : T
1 :
2 : A
3 :
4 : X
5 : YK
6 : ZL

你的结果：
0 : T
1 :
2 : A
3 :
4 : X
5 : YK
6 : ZL

========RIGHT========

运行完毕 15: 03: 42 请再次运行你的程序，以重新生成所有数据进行测试 15: 03: 42 编译通过 15: 03: 46 函数输入的关键字序列（即参数es[]）：
正确结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 :

你的结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 :

========RIGHT========
函数输入的关键字序列（即参数es[]）： W Y F N U
正确结果：
0 : F
1 : UN
2 :
3 : W
4 :
5 : Y
6 :

你的结果：
0 : F
1 : UN
2 :
3 : W
4 :
5 : Y
6 :

========RIGHT========
函数输入的关键字序列（即参数es[]）： J I W Z T L T D
正确结果：
0 : T
1 :
2 :
3 : WI
4 : J
5 : D
6 : LZ

你的结果：
0 : T
1 :
2 :
3 : WI
4 : J
5 : D
6 : LZ

========RIGHT========
函数输入的关键字序列（即参数es[]）： N R I H Z Z P W U
正确结果：
0 :
1 : UN
2 : H
3 : WPI
4 :
5 : R
6 : Z

你的结果：
0 :
1 : UN
2 : H
3 : WPI
4 :
5 : R
6 : Z

========RIGHT========
函数输入的关键字序列（即参数es[]）： U J P D K J Z K O O G Z X
正确结果：
0 :
1 : GU
2 : O
3 : P
4 : XJ
5 : KD
6 : Z

你的结果：
0 :
1 : GU
2 : O
3 : P
4 : XJ
5 : KD
6 : Z

========RIGHT========

运行完毕 15: 03: 46 本道题目已经通过 15: 03: 46 In function ‘int search(HLink)’:

6:28: error: ‘key’ was not declared in this scope; did you mean ‘key_t’?
    6 |             if (p->data == key) {
      |                            ^
      |                            key_t
In function ‘int BuildHashTab(ChainHashTab&, int, HKeyType*)’:

32:9: error: expected ‘,’ or ‘;’ before ‘if’
32 | if (status == 1){
| ^

39:33: error: expected primary-expression before ‘.’ token
39 | H.rcd[index] = newNode; .count++;
| ^

42:2: error: expected ‘}’ at end of input
42 | }
| ^

16:57: note: to match this ‘{’
16 | int BuildHashTab(ChainHashTab &H, int n, HKeyType es[]) {
| ^

编译失败 15: 06: 36 运行失败 15: 06: 36 In function ‘int BuildHashTab(ChainHashTab&, int, HKeyType*)’:

34:33: error: expected primary-expression before ‘.’ token
34 | H.rcd[index] = newNode; .count++;
| ^

37:6: error: expected ‘}’ at end of input
37 | }
| ^

3:57: note: to match this ‘{’
3 | int BuildHashTab(ChainHashTab &H, int n, HKeyType es[]) {
| ^

编译失败 15: 07: 27 运行失败 15: 07: 27 In function ‘int BuildHashTab(ChainHashTab&, int, HKeyType*)’:

28:13: error: ‘continus’ was not declared in this scope
28 | continus ;
| ^

编译失败 15: 08: 04 运行失败 15: 08: 04 In function ‘int BuildHashTab(ChainHashTab&, int, HKeyType*)’:

28:13: error: ‘continus’ was not declared in this scope
28 | continus ;
| ^

编译失败 15: 08: 44 运行失败 15: 08: 44 编译通过 15: 09: 35 函数输入的关键字序列（即参数es[]）：
正确结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 :

你的结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 :

========RIGHT========
函数输入的关键字序列（即参数es[]）： L R S O H
正确结果：
0 :
1 :
2 : HO
3 :
4 :
5 : R
6 : SL

你的结果：
0 :
1 :
2 : HO
3 :
4 :
5 : R
6 : SL

========RIGHT========
函数输入的关键字序列（即参数es[]）： M G Q G I O
正确结果：
0 : M
1 : G
2 : O
3 : I
4 : Q
5 :
6 :

你的结果：
0 : M
1 : G
2 : O
3 : I
4 : Q
5 :
6 :

========RIGHT========
函数输入的关键字序列（即参数es[]）： Q K Q U K Y P F J
正确结果：
0 : F
1 : U
2 :
3 : P
4 : JQ
5 : YK
6 :

你的结果：
0 : F
1 : U
2 :
3 : P
4 : JQ
5 : YK
6 :

========RIGHT========
函数输入的关键字序列（即参数es[]）： X B Y M L E Z D R S X F
正确结果：
0 : FM
1 :
2 :
3 : B
4 : X
5 : RDY
6 : SZEL

你的结果：
0 : FM
1 :
2 :
3 : B
4 : X
5 : RDY
6 : SZEL

========RIGHT========

运行完毕 15: 09: 36 本道题目已经通过 15: 09: 36 编译通过 15: 09: 38 函数输入的关键字序列（即参数es[]）：
正确结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 :

你的结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 :

========RIGHT========
函数输入的关键字序列（即参数es[]）： Z D L C N
正确结果：
0 :
1 : N
2 :
3 :
4 : C
5 : D
6 : LZ

你的结果：
0 :
1 : N
2 :
3 :
4 : C
5 : D
6 : LZ

========RIGHT========
函数输入的关键字序列（即参数es[]）： O U E E W N H Q
正确结果：
0 :
1 : NU
2 : HO
3 : W
4 : Q
5 :
6 : E

你的结果：
0 :
1 : NU
2 : HO
3 : W
4 : Q
5 :
6 : E

========RIGHT========
函数输入的关键字序列（即参数es[]）： T B C H O S L D J U P
正确结果：
0 : T
1 : U
2 : OH
3 : PB
4 : JC
5 : D
6 : LS

你的结果：
0 : T
1 : U
2 : OH
3 : PB
4 : JC
5 : D
6 : LS

========RIGHT========
函数输入的关键字序列（即参数es[]）： O U B L T G Y W T D M P
正确结果：
0 : MT
1 : GU
2 : O
3 : PWB
4 :
5 : DY
6 : L

你的结果：
0 : MT
1 : GU
2 : O
3 : PWB
4 :
5 : DY
6 : L

========RIGHT========

运行完毕 15: 09: 39 本道题目已经通过 15: 09: 39 编译通过 15: 10: 35 函数输入的关键字序列（即参数es[]）：
正确结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 :

你的结果：
0 :
1 :
2 :
3 :
4 :
5 :
6 :

========RIGHT========
函数输入的关键字序列（即参数es[]）： E E I L X
正确结果：
0 :
1 :
2 :
3 : I
4 : X
5 :
6 : LE

你的结果：
0 :
1 :
2 :
3 : I
4 : X
5 :
6 : LE

========RIGHT========
函数输入的关键字序列（即参数es[]）： R S G D X B F
正确结果：
0 : F
1 : G
2 :
3 : B
4 : X
5 : DR
6 : S

你的结果：
0 : F
1 : G
2 :
3 : B
4 : X
5 : DR
6 : S

========RIGHT========
函数输入的关键字序列（即参数es[]）： V S P C H G O M D
正确结果：
0 : M
1 : G
2 : OHV
3 : P
4 : C
5 : D
6 : S

你的结果：
0 : M
1 : G
2 : OHV
3 : P
4 : C
5 : D
6 : S

========RIGHT========
函数输入的关键字序列（即参数es[]）： E S A Z N L R R R Z F O L
正确结果：
0 : F
1 : N
2 : OA
3 :
4 :
5 : R
6 : LZSE

你的结果：
0 : F
1 : N
2 : OA
3 :
4 :
5 : R
6 : LZSE

========RIGHT========

运行完毕 15: 10: 36 本道题目已经通过 15: 10: 36 保存代码成功 15: 11: 50

	DC04PE04有序输出哈希表中的所有关键字			36秒
	DC04PE15链地址哈希表的构造
	DC04PE30计算链地址哈希表中的冲突次数			9分13秒
	DC04PE35在链地址哈希表中查找关键字，并记录查找过程中发生的冲突次数			56秒