Searching: Chained Hash Table Search And Insertion-1

Algorithm C

Algorithm C (Chained hash table search and insertion). This algorithm looks

for a given key K in an M-node table. If K is not in the table and the table is

not full, K is inserted.

The nodes of the table are denoted by TABLE[i], for 0 <= i <= M, and they

are of two distinguishable types, empty and occupied. An occupied node contains

a key field KEY[i], a link field LINK[i], and possibly other fields.

The algorithm makes use of a hash function h(K). An auxiliary variable

R is also used, to help find empty spaces; when the table is empty, we have

R = M + 1, and as insertions are made it will always be true that TABLE [j] is

occupied for all j in the range R <= j <= M. By convention, TABLE[0] will always

be empty.

C1. [Hash.] Set i <– h(K) + 1. (Now 1 <= i <= M.)

C2. [Is there a list?] If TABLE[i] is empty, go to C6. (Otherwise TABLE[i] is

occupied; we will look at the list of occupied nodes that starts here.)

C3. [Compare.] If K = KEY[i], the algorithm terminates successfully.

C4. [Advance to next.] If LINK[i] != 0, set i <– LINK[i] and go back to step C3.

C5. [Find empty node.] (The search was unsuccessful, and we want to find an

empty position in the table.) Decrease R one or more times until finding

a value such that TABLE[R] is empty. If R = 0, the algorithm terminates

with overflow (there are no empty nodes left); otherwise set LINK[i] <– R,

i <– R.

C6. [Insert new key.] Mark TABLE[i] as an occupied node, with KEY[i] <– K

and LINK[i] <– 0. |

Flow diagram

Coalesced chaining

Java program

In this program, R1,…,RN were simplified to K1,…,KN.

Node.java

package com.algorithms.searching;

/**
* Created with IntelliJ IDEA.
* User: 1O1O
* Date: 12/13/13
* Time: 6:52 PM
* :)~
* Chained Hash Table Search And Insertion:Searching
*/
public class Node {
int KEY;
int LINK;
Node(int key){
KEY = key;
LINK=0;
}
}

Main.java

package com.algorithms.searching;

/**
* Created with IntelliJ IDEA.
* User: 1O1O
* Date: 12/13/13
* Time: 6:52 PM
* :)~
* Chained Hash Table Search And Insertion:Searching
*/
public class Main {

public static Node[] TABLE = new Node[20];
public static int M = 19;
public static int R = M+1;

public static void searchAndInsertNode(int key){
int hash = key%19+1;                  /*Hash function:h(K)*/

if(TABLE[hash] == null){
Node node = new Node(key);
TABLE[hash] = node;
System.out.println(String.format("%4s",key+":")+" not found in the hash table, then insert it in TABLE["+hash+"]");
}else {
do{
if(key == TABLE[hash].KEY){
System.out.println(key+" found in the hash table: TABLE["+hash+"]");
break;
}
if(TABLE[hash].LINK != 0){
hash = TABLE[hash].LINK;
}else {
do{
if(R == 0){
System.out.println("Error: Hash Table Overflow!"+", Key:"+key+" can not be inserted!");
break;
}else {
R--;
if(R!=0 && TABLE[R]==null){
TABLE[hash].LINK = R;
hash = R;
break;
}
}
}while (true);
if(R == 0){
break;
}
Node node = new Node(key);
TABLE[hash] = node;
System.out.println(String.format("%4s",key+":")+" not found in the hash table, then insert it in TABLE["+hash+"]");
break;
}
}while (true);
}
}

public static void main(String[] args) {

/*Prepare the Hash Table*/
System.out.println("Prepare the Hash Table:");
searchAndInsertNode(503);
searchAndInsertNode(87);
searchAndInsertNode(512);
searchAndInsertNode(61);
searchAndInsertNode(908);
searchAndInsertNode(170);
searchAndInsertNode(897);
searchAndInsertNode(275);
searchAndInsertNode(653);
searchAndInsertNode(426);
searchAndInsertNode(154);
searchAndInsertNode(509);
searchAndInsertNode(612);
searchAndInsertNode(677);
searchAndInsertNode(765);
searchAndInsertNode(703);
System.out.println();

/*Print the current Hash Table with 16 nodes*/
System.out.println("Print the current Hash Table with 16 nodes:");
for(int j=1; j<=19; j++){
if(TABLE[j] != null){
System.out.println(String.format("%3s", j+":")+TABLE[j].KEY);
}
}
System.out.println();

/*Search Node 765 in current Hash Table*/
System.out.println("Search Node 765 in current Hash Table:");
searchAndInsertNode(765);
System.out.println();

searchAndInsertNode(1);
searchAndInsertNode(2);
searchAndInsertNode(3);
searchAndInsertNode(4);
searchAndInsertNode(5);
}
}

Outputs

Prepare the Hash Table:
503: not found in the hash table, then insert it in TABLE[10]
87: not found in the hash table, then insert it in TABLE[12]
512: not found in the hash table, then insert it in TABLE[19]
61: not found in the hash table, then insert it in TABLE[5]
908: not found in the hash table, then insert it in TABLE[16]
170: not found in the hash table, then insert it in TABLE[18]
897: not found in the hash table, then insert it in TABLE[17]
275: not found in the hash table, then insert it in TABLE[15]
653: not found in the hash table, then insert it in TABLE[8]
426: not found in the hash table, then insert it in TABLE[9]
154: not found in the hash table, then insert it in TABLE[3]
509: not found in the hash table, then insert it in TABLE[14]
612: not found in the hash table, then insert it in TABLE[13]
677: not found in the hash table, then insert it in TABLE[11]
765: not found in the hash table, then insert it in TABLE[6]
703: not found in the hash table, then insert it in TABLE[1]

Print the current Hash Table with 16 nodes:
1:703
3:154
5:61
6:765
8:653
9:426
10:503
11:677
12:87
13:612
14:509
15:275
16:908
17:897
18:170
19:512

Search Node 765 in current Hash Table:
765 found in the hash table: TABLE[6]

1: not found in the hash table, then insert it in TABLE[2]
2: not found in the hash table, then insert it in TABLE[7]
3: not found in the hash table, then insert it in TABLE[4]
Error: Hash Table Overflow!, Key:4 can not be inserted!
Error: Hash Table Overflow!, Key:5 can not be inserted!

Reference

<< The art of computer programming: Sorting and Searching >> VOLUME 3, DONALD E. KNUTH