用开放地址法中的线性探查法解决冲突实现哈希表的运算

为了更深的理解哈希算法，自己写了用开放地址法中的线性探查法解决冲突实现哈希表的运算。

/**
 * Created by lirui on 14-8-13.
 * 用开放地址法中的线性探查法解决冲突实现哈希表的运算。
 */
public class MyHashSearch {
    public static final int SIZE = 10;
    public static final int NULLKEY = -1;
    public static final int DELKEY = -2;
    public static MyHashTable[] hashTables1 = new MyHashTable[SIZE];
    // 记录hash表中的数量。
    public static int count = 0;


    // 哈希函数  h(key)= key mod p
    public static int hashFunction(int key, int p) {
        return key % p;
    }


    // 解决冲突的函数
    public static int ConlictFunction(int adress) {
        return (adress + 1) % SIZE;
    }


    /**
     * @param hashTables
     * @param p          选择的那个被除数  h(key)= key mod p  h(key)代表地址
     * @param key        要查的关键字
     * @return
     */
    public static int searchHT(MyHashTable[] hashTables, int p, int key) {
        int i = 0, adr;
        adr = hashFunction(key, p);
        while (hashTables[adr].key != NULLKEY && hashTables[adr].key != key) {
            i++;
            adr = ConlictFunction(adr);
        }
        if (hashTables[adr].key == key) {
            return adr;
        } else {
            return -1;
        }
    }


    public static int deleteHT(MyHashTable[] myHashTables, int p, int key) {
        int adr;
        adr = searchHT(myHashTables, p, key);
        if (adr != -1) {
            myHashTables[adr].key = DELKEY;
            count--;
            return 1;
        } else {
            return 0;
        }
    }




    // 将key插入到哈希表中
    public static void insertHT(MyHashTable[] hashTables, int key, int p) {
        int i, adr;
        adr = hashFunction(key, p);
        // 当没有冲突发生的时候
        if (hashTables[adr].key == NULLKEY || hashTables[adr].key == DELKEY) {
            hashTables[adr].key = key;
            hashTables[adr].findcount = 1;
        } else {
            // 如果发生了冲突
            i = 2;
            adr = ConlictFunction(adr);
            while (hashTables[adr].key != NULLKEY && hashTables[adr].key != DELKEY) {
                adr = ConlictFunction(adr);
                i++;
            }
            hashTables[adr].key = key;
            hashTables[adr].findcount = i;
        }
        count++;
    }


    /**
     * @param hashTables
     * @param x          要存入哈希表中的数组
     * @param m          哈希表的长度
     * @param p          哈希参数
     */
    public static void createHT(MyHashTable[] hashTables, int[] x, int m, int p) {
        int i, length = x.length;
        for (i = 0; i < m; i++) {
            hashTables[i].key = NULLKEY;
            hashTables[i].findcount = 0;
        }
        for (i = 0; i < length; i++) {
            insertHT(hashTables, x[i], p);
        }
    }


    public static void main(String[] args) {
        MyHashTable[] hashTables1 = MyHashSearch.hashTables1;
        for (int i = 0; i < MyHashSearch.SIZE; i++) {
            hashTables1[i] = new MyHashTable();
        }
        //int[] x = {2, 49, 303, 100, 30, 1};
        int[] x = {7, 8, 30, 11, 18, 9 ,14};
        createHT(hashTables1, x, MyHashSearch.SIZE, 7);
        for (MyHashTable myHashTable : hashTables1) {
            System.out.println(myHashTable.key + "  探查次数:" + myHashTable.findcount);
        }
        System.out.println(searchHT(hashTables1, 7, 30));
        System.out.println(count);
        deleteHT(hashTables1,7,7);
        System.out.println(count);
        for (MyHashTable myHashTable : hashTables1) {
            System.out.println(myHashTable.key + "  探查次数:" + myHashTable.findcount);
        }
    }
}


class MyHashTable {
    int key; // 关键字域
    String info; // 其他数据域
    int findcount;// 探查次数域


    MyHashTable() {
    }


    MyHashTable(int key, String info, int findcount) {
        this.key = key;
        this.info = info;
        this.findcount = findcount;
    }
}