链接法散列表的 java 实现

最新推荐文章于 2021-03-05 01:57:21 发布

CHOOOU

最新推荐文章于 2021-03-05 01:57:21 发布

阅读量526

点赞数

CC 4.0 BY-SA版权

分类专栏：算法 java 文章标签： java 散列表数据结构

本文链接：https://blog.youkuaiyun.com/one_of_a_kind/article/details/75371187

java 同时被 2 个专栏收录

15 篇文章

订阅专栏

算法

12 篇文章

订阅专栏

本文介绍了一种基于单独链接法解决冲突的散列表实现方法，并通过一个具体的Java代码示例展示了如何构造散列表，包括插入、删除、查找等基本操作。此外，还提供了一个简单的员工信息录入案例来演示散列表的实际运用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

import java.util.*;

/*
 * 此散列表只对提供适当 equals 方法和返回一个 int 型量的 hashCode 方法的对象工作
 */
public class SeparateChainingHashTable<Type> {
    private static final int DEFAULT_TABLE_SIZE = 5;

    private List<Type> [] theLists;
    private int currentSize;        //插入的项数

    private void rehash() {
        List<Type> [] oldLists = theLists;

        //创建一个两倍的表
        theLists = new List[ 2 * theLists.length ];

        for ( int i = 0; i < theLists.length; i++) 
            theLists[i] = new LinkedList<Type>();

        //把旧表插入
        currentSize = 0;
        for ( int i = 0; i < oldLists.length; i++) {
            for ( Type item : oldLists[i])
                insert(item);
        }
    }

    private int myhash( Type x ) {
        int hashVal = x.hashCode();

        hashVal %= theLists.length;
        if ( hashVal < 0 )
            hashVal += theLists.length;

        return hashVal;
    }

    public SeparateChainingHashTable() {
        this(DEFAULT_TABLE_SIZE);
    }

    public SeparateChainingHashTable( int size ) {
        theLists = new LinkedList [ size ];
        for ( int i = 0; i < theLists.length; i++) {
            theLists[i] = new LinkedList<Type>();
        }
    }

    public void insert( Type x ) {
        List<Type> list = theLists[ myhash(x)];
        if ( !list.contains(x) ) {
            list.add(x);

            if (++currentSize > 2 * theLists.length)  
                rehash();
        }
    }

    public void remove( Type x ) {
        List<Type> list = theLists[ myhash(x) ];
        if ( list.contains(x)) {
            list.remove(x);
            currentSize--;
        }
    }

    public boolean contains( Type x ) {
        List<Type> list = theLists[ myhash(x) ];
        return list.contains(x);
    }

    public void makeEmpty() {
        for( int i = 0; i < theLists.length; i++) 
            theLists[i].clear();
        currentSize = 0;
    }

    public void print() {
        for(int i = 0; i < theLists.length; i++) {
            System.out.print(i);
            System.out.println(theLists[i]);
        }
    }

    public static void main( String [] args ) {
        Scanner scanner = new Scanner(System.in);
        SeparateChainingHashTable<Employee> hashTable = new SeparateChainingHashTable<>();

        System.out.println("请输入名字：");
        String n = scanner.next();

        while ( !n.equals("!") ) {
            Employee employee = new Employee(n);
            hashTable.insert(employee);
            n = scanner.next();
        }
        hashTable.print();
        scanner.close();
    }
}

class Employee {
    private String name;

    public boolean equals( Object rhs ) {
        return rhs instanceof Employee && name.equals( ( (Employee)rhs).name );
    }

    public int hashCode() {
        return name.hashCode();
    }

    public Employee( String n ) {
        name = n;
    }

    public String toString() {
        return name;
    }
}

输入

mike
job
hah
wow
sha
bob
haya
llo
leilei
niuniu
didi
!

输出

0[didi]
1[]
2[mike, leilei]
3[]
4[]
5[job, hah]
6[sha]
7[bob, llo]
8[niuniu]
9[wow, haya]