哈希表思路图解和代码实现

最新推荐文章于 2022-07-20 14:09:25 发布
最新推荐文章于 2022-07-20 14:09:25 发布
阅读量856 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 java 算法 哈希表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40223983/article/details/114382810
版权

原文链接传送门

哈希表(散列)-Google上机题

看一个实际需求，google公司的一个上机题:

有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的id时,要求查找到该员工的 所有信息.

要求: 不使用数据库,尽量节省内存,速度越快越好=>哈希表(散列)

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 15 111 % 15

img

哔哩哔哩动画

img img

哔哩哔哩动画

哈希表就是数组里面存储链表

google公司的一个上机题:

有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,名字,住址…),当输入该员工的id时,要求查找到该员工的 所有信息.

要求:

不使用数据库,速度越快越好=>哈希表(散列) 添加时，保证按照id从低到高插入 [课后思考：如果id不是从低到高插入，但要求各条链表仍是从低到高，怎么解决?]

  1. 使用链表来实现哈希表, 该链表不带表头[即: 链表的第一个结点就存放雇员信息]
  2. 思路分析并画出示意图
  3. 代码实现[增删改查(显示所有员工，按id查询)]

// 哈希表之所以能够提高效率,是因为他能够同时管理多个链表

Emp

/**
 * 表示一个雇员
 */
class Emp{
    public int id;
    public String name;
    public Emp next;//next 默认为空

    public Emp(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

HashTab

///创建hashTab 管理多条链表

class HashTab{
    // 数组里面放的是链表
    private EmpLinkedList[] empLinkedListArray;
    //
    private Integer size = 7;


    // 构造器
    public HashTab(int size) {
        // 初始化empLinkedListArray
        empLinkedListArray = new EmpLinkedList[size];
        // ? 留一个坑
        // 这里能直接用么
        /*
        * add:添加雇员
        list:显示雇员
        exit:退出雇员
        add
        输入id
        tom
        Exception in thread "main" java.util.InputMismatchException
            at java.util.Scanner.throwFor(Scanner.java:864)
            at java.util.Scanner.next(Scanner.java:1485)
            at java.util.Scanner.nextInt(Scanner.java:2117)
            at java.util.Scanner.nextInt(Scanner.java:2076)
            at com.atguigu.hashtab.HashTabDemo.main(HashTabDemo.java:30)

        Process finished with exit code 1

                * */
        // 这个时候不要忘了, 分别初始化 每个链表
        for (int i = 0; i < size; i++) {
            // 数组中的每一个元素都需要创建一把
            empLinkedListArray[i] = new EmpLinkedList();
        }
    }

    // 添加雇员

    public void add(Emp emp) {
        // 根据员工的id,得到该员工应当加入到,哪条链表
        int empLinkedListNO = hashFun(emp.id);
        // 将emp 添加到对应的链表中
        empLinkedListArray[empLinkedListNO].add(emp);

    }

    // 不管你是什么操作,总是要找链表
    // 遍历所有的链表
    public void list() {
        // 遍历Hash表
        for (int i = 0; i < size; i++) {
            empLinkedListArray[i].list(i);
        }
    }

    // 编写一个散列函数
    // 散列函数有很多种写法
    // 这里使用简单的方法-取模法
    public int hashFun(int id) {
        return id % size;
    }

    /**
     * 更根据输入的id,查找雇员
     * @param id
     */
    public void findEmpById(int id) {
        // 使用散列函数确定到哪条链表查找
        int empLinkedListNO = hashFun(id);
        Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
        if (emp != null) {
            // 说明找到了
            System.out.println("找到了该雇员");
            System.out.printf("在第%d条链表中找到了该雇员,id = %d",id,empLinkedListNO+1);
        } else {
            System.out.println("在哈希表中,没有找到该雇员~");
        }
    }
}

EmpLinkedList

class EmpLinkedList{
    // 头指针, 执行第一个Emp,因此我们这个链表的head,是直接 指向第一个Emp
    private Emp head;

    //添加雇员到链表
    // 说明.
    // 1. 假定,当添加雇员的时候,id是自增长的,即id 的分配总是从小到大

    public void add(Emp emp) {
        // 如果是添加第一个雇员
        if (head == null) {
            head = emp;
            return;
        }
        // 如果不是添加第一个雇员,则使用一个辅助的指针,帮助定位到最后
        Emp currEmp = head;
        while (true) {
            if (currEmp.next == null) {
                // 说明到链表最后
                break;
            }
            // 后移
            currEmp = currEmp.next;
        }
        // 退出时,直接将emp 加入链表
        currEmp.next = emp;

    }

    // 遍历链表的雇员信息
    public void list(int no) {
        // 判断是否为空
        if (head == null) {
            // 说明链表为空
            System.out.println("当前链"+no+"表为空!");
            return;
        }
        // 没有空
//        打印信息
        System.out.println("当前链"+no+"表的信息为");
        // 辅助指针
        Emp currEmp = head;
        while (true) {
            System.out.printf("=> id =%d name = %s\t",currEmp.id,currEmp.name);
            if (currEmp.next == null) {
                // 说明,currEmp 已经是最后节点
                break;
            }
            // 后移 遍历
            currEmp = currEmp.next;
        }
        System.out.println();
    }


    /**
     *     // 根据id 查找雇员
     *    // 如果查找到 ,就返回Emp,如果没有找打到,就返回null
     * @param id
     * @return
     */
    public Emp findEmpById(int id) {
        // 判断链表是否为空
        if (head == null) {
            System.out.println("链表为空");
            return null;
        }

        //辅助指针
        Emp curEmp = head;
        while (true) {
            //
            if (curEmp.id == id) {
                // 找到
                break;
            //  这个时候,currEmp就指向了要查找的雇员
            }
            // 退出
            if (curEmp.next == null) {
                // 说明遍历当前链表没有找到该雇员
                curEmp = null;
            }
            // 后移
            curEmp = curEmp.next;
        }
        return curEmp;
    }
}

主函数

public static void main(String[] args) {
    // 创建哈希表
    HashTab hashTab = new HashTab(7);

    // 写一个简单的菜单来测试
    String key = "";
    Scanner scanner = new Scanner(System.in);
    while (true) {
        System.out.println("add:添加雇员");
        System.out.println("list:显示雇员");
        System.out.println("find:查找雇员");
        System.out.println("exit:退出雇员");

        key = scanner.next();
        switch (key) {
            case "add":
                System.out.println("输入id");
                int id = scanner.nextInt();
                System.out.println("输入名字");
                String name = scanner.next();
                // 创建雇员
                Emp emp = new Emp(id, name);
                hashTab.add(emp);
                break;
            case "list":
                hashTab.list();
                break;
            case "find":
                System.out.println("输入id");
                int findId = scanner.nextInt();
                hashTab.findEmpById(findId);
                break;
            case "exit":
                scanner.close();
                System.exit(0);
            default:
                break;
        }
    }
}

add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
1
输入名字
tom
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
2
输入名字
jack
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
3
输入名字
pin
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
6
输入名字
nanc
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
list
当前链0表为空!
当前链1表的信息为
=> id =1 name = tom	
当前链2表的信息为
=> id =2 name = jack	
当前链3表的信息为
=> id =3 name = pin	
当前链4表为空!
当前链5表为空!
当前链6表的信息为
=> id =6 name = nanc	
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
123
输入名字
sme
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
list
当前链0表为空!
当前链1表的信息为
=> id =1 name = tom	
当前链2表的信息为
=> id =2 name = jack	
当前链3表的信息为
=> id =3 name = pin	
当前链4表的信息为
=> id =123 name = sme	
当前链5表为空!
当前链6表的信息为
=> id =6 name = nanc	
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
678
输入名字
vicr
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
list
当前链0表为空!
当前链1表的信息为
=> id =1 name = tom	
当前链2表的信息为
=> id =2 name = jack	
当前链3表的信息为
=> id =3 name = pin	
当前链4表的信息为
=> id =123 name = sme	
当前链5表为空!
当前链6表的信息为
=> id =6 name = nanc	=> id =678 name = vicr	
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
389
输入名字
wef
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
9
输入名字
zho
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
list
当前链0表为空!
当前链1表的信息为
=> id =1 name = tom	
当前链2表的信息为
=> id =2 name = jack	=> id =9 name = zho	
当前链3表的信息为
=> id =3 name = pin	
当前链4表的信息为
=> id =123 name = sme	=> id =389 name = wef	
当前链5表为空!
当前链6表的信息为
=> id =6 name = nanc	=> id =678 name = vicr	
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
34
输入名字
mach
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
list
当前链0表为空!
当前链1表的信息为
=> id =1 name = tom	
当前链2表的信息为
=> id =2 name = jack	=> id =9 name = zho	
当前链3表的信息为
=> id =3 name = pin	
当前链4表的信息为
=> id =123 name = sme	=> id =389 name = wef	
当前链5表为空!
当前链6表的信息为
=> id =6 name = nanc	=> id =678 name = vicr	=> id =34 name = mach	
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
find
输入id
8
Exception in thread "main" java.lang.NullPointerException
	at com.atguigu.hashtab.EmpLinkedList.findEmpById(HashTabDemo.java:237)
	at com.atguigu.hashtab.HashTab.findEmpById(HashTabDemo.java:128)
	at com.atguigu.hashtab.HashTabDemo.main(HashTabDemo.java:44)

Process finished with exit code 1

最后这里置空要 加上break

if (curEmp.next == null) {
                // 说明遍历当前链表没有找到该雇员
                curEmp = null;
                break;
            }

这下就可以了

add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
1
输入名字
tom
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
2
输入名字
nancy
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add4
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
add
输入id
4
输入名字
victor
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
list
当前链0表为空!
当前链1表的信息为
=> id =1 name = tom	
当前链2表的信息为
=> id =2 name = nancy	
当前链3表为空!
当前链4表的信息为
=> id =4 name = victor	
当前链5表为空!
当前链6表为空!
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
find
输入id
6
链表为空
在哈希表中,没有找到该雇员~
add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员
find
输入id
4
找到了该雇员
在第4条链表中找到了该雇员,id = 5add:添加雇员
list:显示雇员
find:查找雇员
exit:退出雇员

完整代码

package com.atguigu.hashtab;

import java.util.Scanner;

/**
 * ClassName:  <br/>
 * Description:  <br/>
 * Date: 2021-02-24 13:10 <br/>
 * <br/>
 * @project data_algorithm
 * @package com.atguigu.hashtab
 */
public class HashTabDemo {
    public static void main(String[] args) {
        // 创建哈希表
        HashTab hashTab = new HashTab(7);

        // 写一个简单的菜单来测试
        String key = "";
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("add:添加雇员");
            System.out.println("list:显示雇员");
            System.out.println("find:查找雇员");
            System.out.println("exit:退出雇员");

            key = scanner.next();
            switch (key) {
                case "add":
                    System.out.println("输入id");
                    int id = scanner.nextInt();
                    System.out.println("输入名字");
                    String name = scanner.next();
                    // 创建雇员
                    Emp emp = new Emp(id, name);
                    hashTab.add(emp);
                    break;
                case "list":
                    hashTab.list();
                    break;
                case "find":
                    System.out.println("输入id");
                    int findId = scanner.nextInt();
                    hashTab.findEmpById(findId);
                    break;
                case "exit":
                    scanner.close();
                    System.exit(0);
                default:
                    break;
            }
        }
    }
}

///创建hashTab 管理多条链表

class HashTab{
    // 数组里面放的是链表
    private EmpLinkedList[] empLinkedListArray;
    //
    private Integer size = 7;


    // 构造器
    public HashTab(int size) {
        // 初始化empLinkedListArray
        empLinkedListArray = new EmpLinkedList[size];
        // ? 留一个坑
        // 这里能直接用么
        /*
        * add:添加雇员
        list:显示雇员
        exit:退出雇员
        add
        输入id
        tom
        Exception in thread "main" java.util.InputMismatchException
            at java.util.Scanner.throwFor(Scanner.java:864)
            at java.util.Scanner.next(Scanner.java:1485)
            at java.util.Scanner.nextInt(Scanner.java:2117)
            at java.util.Scanner.nextInt(Scanner.java:2076)
            at com.atguigu.hashtab.HashTabDemo.main(HashTabDemo.java:30)

        Process finished with exit code 1

                * */
        // 这个时候不要忘了, 分别初始化 每个链表
        for (int i = 0; i < size; i++) {
            // 数组中的每一个元素都需要创建一把
            empLinkedListArray[i] = new EmpLinkedList();
        }
    }

    // 添加雇员

    public void add(Emp emp) {
        // 根据员工的id,得到该员工应当加入到,哪条链表
        int empLinkedListNO = hashFun(emp.id);
        // 将emp 添加到对应的链表中
        empLinkedListArray[empLinkedListNO].add(emp);

    }

    // 不管你是什么操作,总是要找链表
    // 遍历所有的链表
    public void list() {
        // 遍历Hash表
        for (int i = 0; i < size; i++) {
            empLinkedListArray[i].list(i);
        }
    }

    // 编写一个散列函数
    // 散列函数有很多种写法
    // 这里使用简单的方法-取模法
    public int hashFun(int id) {
        return id % size;
    }

    /**
     * 更根据输入的id,查找雇员
     * @param id
     */
    public void findEmpById(int id) {
        // 使用散列函数确定到哪条链表查找
        int empLinkedListNO = hashFun(id);
        Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
        if (emp != null) {
            // 说明找到了
            System.out.println("找到了该雇员");
            System.out.printf("在第%d条链表中找到了该雇员,id = %d",id,empLinkedListNO+1);
        } else {
            System.out.println("在哈希表中,没有找到该雇员~");
        }
    }
}


/**
 * 表示一个雇员
 */
class Emp{
    public int id;
    public String name;
    public Emp next;//next 默认为空

    public Emp(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

class EmpLinkedList{
    // 头指针, 执行第一个Emp,因此我们这个链表的head,是直接 指向第一个Emp
    private Emp head;

    //添加雇员到链表
    // 说明.
    // 1. 假定,当添加雇员的时候,id是自增长的,即id 的分配总是从小到大

    public void add(Emp emp) {
        // 如果是添加第一个雇员
        if (head == null) {
            head = emp;
            return;
        }
        // 如果不是添加第一个雇员,则使用一个辅助的指针,帮助定位到最后
        Emp currEmp = head;
        while (true) {
            if (currEmp.next == null) {
                // 说明到链表最后
                break;
            }
            // 后移
            currEmp = currEmp.next;
        }
        // 退出时,直接将emp 加入链表
        currEmp.next = emp;

    }

    // 遍历链表的雇员信息
    public void list(int no) {
        // 判断是否为空
        if (head == null) {
            // 说明链表为空
            System.out.println("当前链"+no+"表为空!");
            return;
        }
        // 没有空
//        打印信息
        System.out.println("当前链"+no+"表的信息为");
        // 辅助指针
        Emp currEmp = head;
        while (true) {
            System.out.printf("=> id =%d name = %s\t",currEmp.id,currEmp.name);
            if (currEmp.next == null) {
                // 说明,currEmp 已经是最后节点
                break;
            }
            // 后移 遍历
            currEmp = currEmp.next;
        }
        System.out.println();
    }


    /**
     *     // 根据id 查找雇员
     *    // 如果查找到 ,就返回Emp,如果没有找打到,就返回null
     * @param id
     * @return
     */
    public Emp findEmpById(int id) {
        // 判断链表是否为空
        if (head == null) {
            System.out.println("链表为空");
            return null;
        }

        //辅助指针
        Emp curEmp = head;
        while (true) {
            //
            if (curEmp.id == id) {
                // 找到
                break;
            //  这个时候,currEmp就指向了要查找的雇员
            }
            // 退出
            if (curEmp.next == null) {
                // 说明遍历当前链表没有找到该雇员
                curEmp = null;
                break;
            }
            // 后移
            curEmp = curEmp.next;
        }
        return curEmp;
    }
}

扩展

删除功能???

原文链接传送门

秋叶夏风
关注
专栏目录
图解算法系列(十一)：哈希表
人生代码 ---- 公众号
04-23 1603
哈希表是一种存储记录的连续内存，通过哈希表函数的应用，可以快速存取与查找数据，基本上，所谓哈希法，就是将本身的键值，通过特定的数学函数运算或使用其他方法，转换成相对应的数据存储地址，如图所示 现在我们介绍有关哈希函数的相关名词 bucket（桶）哈希表中存储数据的位置，每一个位置对应到唯一一个地址，桶就好比一个记录 slot（槽）每一个记录中可能包含好几个字段，而slot☞就是“桶”中的字段。...
go实现哈希表
实践求真知
05-31 1000
一点睛 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 c317.png 三 使用 hashtable 来实现一个雇员的管理系统 1需求 有一个公司，当有新的员工来报道时，要求将该员工的信息加入(id、性别、年龄、住址..)，当输入该员工的 id 时，要求查找到该员工的 所有信息。 要求： a 不使用数据库..
「数据结构」图解哈希表（JavaScript实现）
梅花寺
07-20 547
哈希函数是一种将“键”转换为“索引”的逻辑规则。它的设计好坏对哈希表的性能影响巨大。优良的哈希函数能够最大程度的减少哈希冲突，使得哈希表中的元素分布得尽可能的均匀，离散程度更大，这样哈希表就会性能优越；较差的哈希函数设计，带来的可能是一场灾难，哈希冲突严重，空间利用率低，时间复杂度呈线性恶化，造成频繁的扩容操作。...
哈希表（带图解）
xu_haopeng的博客
11-28 5487
哈希表 常见的搜索方式： 1、顺序搜索——O(N) 2、二分搜索——O(log₂N) 3、搜索树结构中的查找：二叉树搜索——O(N)，AVL——O(log₂N)，红黑树——O(log₂N) 以上都需要比较，那有没有不需要比较就能查找的方法呢？ 概念 顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log₂N)，搜索的效率取决于搜索过程中元素的比较次数。 理想的搜索方法：可以不经过任何比较
哈希表的设计
weixin_30507481的博客
01-10 144
哈希表充分体现了算法设计领域的经典思想：空间换区时间 哈希表是时间和空间之间的一个平衡 哈希函数的设计很重要 键通过哈希函数得到索引分布均匀 哈希函数的设计： 1.键通过哈希函数得到索引分布均匀：特殊领域的哈希函数设计方式甚至有专门的论文这个不考虑，我们只是设计最普通的函数设计： 整型：小范围的正整数直接使用，小范围的负整数进行偏移比如：-100-100可以偏移成0-200...
哈希表（HashTable）
热门推荐
Cdreamfly的博客
07-13 5万+
哈希表：也叫做散列表。是根据关键字和值（Key-Value）直接进行访问的数据结构。也就是说，它通过关键字 key 和一个映射函数 Hash(key) 计算出对应的值 value，然后把键值对映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希函数（散列函数），用于存放记录的数组叫做 哈希表（散列表）。 哈希表的关键思想是使用哈希函数，将键 key 和值 value 映射到对应表的某个区块中。可以将算法思想分为两个部分：哈希表的原理示例图如下所示： 哈希函数：将哈希表中元素的关键键值映射为元
【Java版】图解哈希表
Gebo的博客
03-17 655
哈希表的基本介绍 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。构造散列函数的方式有多种，如数字分析法，随机数法等，本篇用的是取模法。 以下图为例，图中左边是一个长度为16的数组，数组里每一个元素是一个链表，这里是...
数据结构---散列表（哈希表）链地址法
化身强盗的博客
12-22 4878
散列表链地址法基本思想是将相同散列地址的元素放在同一个单链表中，即称同义词链表。例如此时我们设一个散列函数H(key)=key%n，则可以定义一个一维数组，大小为n，数组元素对应关键字模n所得的数字。 如下图：n为13，各关键字模13后插入对应值的表中。 代码部分 存储结构： typedef struct hashnode { int data; struct hashnode* next; }hashnode,*hashbit; data存元素值，next指向冲突元素地址。 相关函数：
用数组+链表实现哈希表
ALi的博客
11-21 864
代码地址https://gitee.com/ALi_L/javaDataStructurs.git目录 思路 图解如下 各个代码 整体代码 思路 用链表来存储数据；Emp 用数组来存放一个一个的链表；EmpLinkedList 再用一个类来管理数组。HashTab 图解如下 各个代码 1.节点Emp class Emp { private int id; private String name; public Emp next; public..
【C++ STL】哈希 Hash（闭散列、开散列介绍及其实现）
codewinter的博客
06-26 2789
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(log2N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个 unordered 系列的关联式容器，这4个容器与红黑树结构的关联式容器底层结构不同，是哈希表（哈希其实就是一种散列，一种映射）哈希表结构的 unordered 系列的关联式容器与红黑树结构的关联式容器 map/set/multimap/mul
哈希表存储的基本思想
12-12
哈希表存储的基本思想是以数据表中的每个记录的关键字 k为自变量 通过一种函数H k 计算出函数值
开局一张图帮你充分理解哈希表(散列表)
weixin_61523952的博客
05-13 2027
思维导图助你理解哈希表
链表哈希表的简单思路及其实现
爪哇岛民工的博客
06-19 525
哈希表的实现其实数组+链表，只要掌握了链表的操作写哈希表并不难。 哈希表有一个数组，里面存放的是链表，哈希表会根据一个函数决定把数据存入到哪条链表，并对其操作 首先先实现一个链表 这是一个雇员类： public class Emp { public int id; public String name; public Emp next; public Emp(int id, String name) { this.id = id; this
哈希表的概念和设计
codecuter的博客
07-21 555
4.哈希表 1.哈希表的基本概念 哈希表适合用于储存一些关键字和存储地址存在某种函数关系的数据。 储存地址=h（key）； 这样储存元素的数据结构就叫做哈希表。 2.哈希表中的一些概念 1.哈希函数和哈希地址 假设存在m个储存空间，我们想要储存n个对象。 那么哈希函数h(k)就是把关键字为ki的对象储存在相应的哈希地址中。 此时的哈希表就是长度为m的（m<=n）的内存单元。 2.哈希冲突 对于两个关键字ki和kj（i!=j），并且ki！=kj，但是h(ki)=h(kj)的现象兼做哈希冲突，也叫做同义词
哈希表思路分析及代码实现
lu_long的博客
12-12 202
哈希表 哈希表（散列）-Google上机题 看一个实际需求，google公司的一个上机题： 有一个公司，当有新的员工来报道时，要求将该员工的信息加入（id，性别，年龄，住址.），当输入该员工的id时，要求查找到该员工的所有信息。 要求：不使用数据库，尽量节省内存，速度越快越好=>哈希表（散列） 哈希表的基本介绍 散列表（Hashtable，也叫哈希表），是根据关键码值（Key value...
【图解数据结构】外行人也能看懂的哈希表
JavaEdge全是干货的技术号
09-01 1868
在Word里输入一个错误的英文单词，它就会用标红的方式提示“拼写错误”。Word的这个单词拼写检查功能，虽然很小但却非常实用。是如何实现的呢？ 什么是散列？ 散列表，Hash Table，用数组支持按照下标随机访问数据的特性，所以散列表其实就是数组的一种扩展，由数组演化而来。 假如有89名候选人参加大选。为了方便记录投票，每个候选人胸前会贴上自己的参赛号码。这89名选手的编号依次是1到89。 通过编号快速找到对应的选手信息。你怎么做？ 可以把这89人的编号跟数组下标对应，查询编号x的人时，只需将下标为x的数
哈希表的实现
李余通的博客
10-09 529
哈希表的实现 何为哈希表 简单来说，哈希表是一种存储结构，它存储的数据是 key:value 类型的。通过空间换时间的方法来加快查询速度，具体思想是如下： 使用一个较大的一维数组存储value，这个数组为Array 实现一个哈希函数，使得hash(key)的值在上一步的一维数组下标范围内 如此，对于任意的key:value，使用hash(key)，之后就可以知道value在数组中存储的下标，存取...
哈希表（散列表）原理详解
coolwriter的博客
05-20 1244
一、什么是哈希表？   哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。记录的存储位置=f(关键字)这里的对应关系f称为散列函数，又称为哈希（Hash函数），采用散列技术将记录存储在一块连续的存储空间中，这块连续存储...
C语言实现哈希表通讯录
"C语言基于哈希表实现通讯录的代码示例，包含创建、插入、查找和打印功能，使用哈希函数进行电话号码的存储定位。" 在C语言编程中，哈希表是一种非常实用的数据结构，它能够提供快速的插入、查找和删除操作。在这个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值