散列表的实际应用

最新推荐文章于 2022-03-28 10:52:08 发布
最新推荐文章于 2022-03-28 10:52:08 发布
阅读量722 收藏 2
点赞数
分类专栏： 数据结构 文章标签： hash结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27293643/article/details/103334368
版权

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

图:

通过题目练习哈希表：

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

1、第一种方法新增不能按照有序新增：

package com.yu.hash;

import java.util.Scanner;

/**
 * 哈希算法
 * @author Administrator
 *
 */
public class HashTableDemo2 {

    public static void main(String[] args) {
        HashTab hashTable = new HashTab(3);
        Scanner scanner = new Scanner(System.in);
        String key = "";
        while(true) {
            System.out.println("add:增加用户");
            System.out.println("list:显示用户");
            System.out.println("find:根据id查找用户");
            System.out.println("update:修改用户");
            System.out.println("del:删除用户");
            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();
                User user = new User(id,name);
                hashTable.add(user);
                break;
            case "list":
                hashTable.showList();
                break;
            case "find":
                System.out.println("请输入id");
                id = scanner.nextInt();
                hashTable.getById(id);
                break;
            case "update":
                System.out.println("请输入id");
                id = scanner.nextInt();
                System.out.println("请输入需要修改姓名");
                name = scanner.next();
                user = new User(id,name);
                hashTable.updateUser(user);
                break;
            case "del":
                System.out.println("请输入id");
                id = scanner.nextInt();
                hashTable.del(id);
                break;
            case "exit":
                scanner.close();
                System.exit(0);
                break;
            }
        }
    }
    
}

/**
 * 创建一个hashTable
 */
class HashTab{
    private LinkedListDemo[] lLinkedListDemo = null;
    private int size;//一共有多少个链表
    /**
     * 创建构造器
     * @param size
     */
    public HashTab(int size) {
        this.size = size;
        lLinkedListDemo = new LinkedListDemo[size];
        for (int i = 0; i < size; i++) {
            lLinkedListDemo[i] = new LinkedListDemo();
        }
    }
    
    /**
     * 添加用户
     */
    public void add(User user) {
        //获取散列值来确定放在哪个链表上
        int hasNum = hasFun(user.getId());
        lLinkedListDemo[hasNum].add(user);
    }
    
    
    /**
     * 遍历用户
     */
    public void showList() {
        for (int i = 0; i < size; i++) {
            lLinkedListDemo[i].showList(i);
        }
    }
    
    /**
     * 根据id查找用户
     */
    public void getById(int id) {
        //获取散列值来确认去哪个链表上获取用户
        int hasNum = hasFun(id);
        User user = lLinkedListDemo[hasNum].getById(id);
        if(user == null) {
            System.out.println("查找的用户不存在!");
        }else {
            System.out.println(user.toString());
        }
    }
    
    /**
     * 修改用户
     */
    public void updateUser(User user) {
        //获取散列值
        int hasNum = hasFun(user.getId());
        lLinkedListDemo[hasNum].update(user);
    }

    /**
     * 删除用户
     * @param id
     */
    public void del(int id) {
        //获取散列值
        int hasNum = hasFun(id);
        lLinkedListDemo[hasNum].delete(id);
    }
    
    /**
     * 编写散列函数来获取散列值
     * @param id
     * @return
     */
    private int hasFun(Integer id) {
        
        return id % size;
    }
    
            
}

/**
 * 创建链表信息
 * @author Administrator
 *
 */
class LinkedListDemo{
    private User head;//链表的头结点
    
    //增加链表
    public void add(User user) {
        if(head == null) {
            head = user;
            return;
        }
        User curUser = head;
        while(true) {
            if(curUser.getNext() == null) {
                break;
            }
            curUser = curUser.getNext();
        }
        curUser.setNext(user);
    }
    
    /**
     * 删除用户
     * 
     * @param id
     */
    public void delete(int id) {
        User delUser = getById(id);
        if (delUser == null) {
            System.out.println("该用户不存在，请检查");
            return;
        }
        // 找到该Id的用户的上一级
        User temp = new User(-1, "");
        temp.setNext(head);
        while (true) {
            if (temp.getNext().getId() == id) {
                break;
            }
            temp = temp.getNext();
        }
        // 找到之后把Temp指向当前的值向前移动一下
        temp.setNext(temp.getNext().getNext());
        // 然后把值赋值给head
        if (head.getId() == id) {
            head = temp.getNext();
        }
    }
    


    /**
     * 修改用户
     * @param user
     */
    public void update(User user) {
        User updateUser = getById(user.getId());
        if(updateUser == null) {
            System.out.println("该用户不存在，请检查");
            return;
        }
        //找到该Id的用户
        User temp = head;
        while(true) {
            if(temp.getId() == user.getId()) {
                break;
            }
        }
        temp.setName(user.getName());
        System.out.println("修改成功！");
    }
    
    
    
    

    /**
     * 遍历用户
     */
    public void showList(int no) {
        if(head == null) {
            System.out.println("第"+(no+1)+"个链表的用户为空");
            return;
        }
        System.out.println("第"+(no+1)+"个链表的用户:");
        User curUser = head;
        while(true) {
            System.out.printf("=>id=%d name=%s\t",curUser.getId(),curUser.getName());
            if(curUser.getNext() == null) {
                break;
            }
            curUser = curUser.getNext();
        }
        System.out.println();
    }
    
    /**
     * 根据Id查找用户
     */
    public User getById(int id) {
        if(head == null) {
            return null;
        }
        User curUser = head;
        while(true) {
            if(curUser.getId() == id) {
                
                break;
            }
            if(curUser.getNext() == null) {
                curUser = null;
                break;
            }
            curUser = curUser.getNext();
        }
        return curUser;
    }
}

/**
 * 创建用户信息
 * @author Administrator
 *
 */
class User{
    private Integer id;
    private String name;
    private User next;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public User getNext() {
        return next;
    }
    public void setNext(User next) {
        this.next = next;
    }
    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", next=" + next + "]";
    }
    
}
 

第二种方法可以完成对有序数据的新增：

package com.yu.hash;

import java.util.Scanner;

/**
 *     哈希算法的操作
 * @author Administrator
 *
 */
public class HashTableDemo3 {

    public static void main(String[] args) {
        HashTab1 hashTable = new HashTab1(3);
        Scanner scanner = new Scanner(System.in);
        String key = "";
        while(true) {
            System.out.println("add:增加用户");
            System.out.println("ll:显示用户");
            System.out.println("find:根据id查找用户");
            System.out.println("update:修改用户");
            System.out.println("del:删除用户");
            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();
                User1 user = new User1(id,name);
                hashTable.add(user);
                break;
            case "ll":
                hashTable.showList();
                break;
            case "find":
                System.out.println("请输入id");
                id = scanner.nextInt();
                hashTable.findById(id);
                break;
            case "update":
                System.out.println("请输入id");
                id = scanner.nextInt();
                System.out.println("请输入需要修改姓名");
                name = scanner.next();
                user = new User1(id,name);
                hashTable.update(user);
                break;
            case "del":
                System.out.println("请输入id");
                id = scanner.nextInt();
                hashTable.del(id);
                break;
            case "exit":
                scanner.close();
                System.exit(0);
                break;
            }
        }
    }
}

/**
 * 创建hashTable
 */
class HashTab1{
    //创建一个链表的数据
    private LinkedListDemo1[] linkedArray = null;
    int size = 0;
    
    /**
     * 创建构造方法
     * @param size
     */
    public HashTab1(int size) {
        this.size = size;
        linkedArray = new LinkedListDemo1[size];
        for (int i = 0; i < size; i++) {
            linkedArray[i] = new LinkedListDemo1();
        }
    }
    
    /**
     * 新增数据
     */
    public void add(User1 user) {
        //得到散列值，这样确认散列到那个链表上面
        int hasNum = hasFun(user.getId());
        linkedArray[hasNum].add(user);
    }
    
    /**
     * 修改数据
     * @param id
     * @return
     */
    public void update(User1 user) {
        //得到散列值，这样确认散列到那个链表上面
        int hasNum = hasFun(user.getId());
        linkedArray[hasNum].update(user);
    }

    /**
     * 遍历元素
     * @param id
     * @return
     */
    public void showList() {
        for (int i = 0; i < size; i++) {
            linkedArray[i].showList(i);
        }
    }
    
    /**
     * 根据id查找元素
     * @param id
     * @return
     */
    
    public void findById(int id) {
        int hasNum = hasFun(id);
        User1 user = linkedArray[hasNum].findById(id);
        if(user == null) {
            System.out.println("用户数据不存在");
        }else {
            System.out.println("用户:" + user.toString());
        }
    }
    
    /**
     * 删除元素
     * @param id
     * @return
     */
    public void del(int id) {
        int hasNum = hasFun(id);
        linkedArray[hasNum].del(id);
    }
    
    
    private int hasFun(Integer id) {
        
        return id % size;
    }
}

/**
 * 定义链表信息
 */
class LinkedListDemo1{
    //定义单个节点的值
    private User1 head = new User1(0,"");
    
    //定义新增的方法，有序新增
    public void add(User1 user) {
        //定义一个临时节点
        User1 temp = head;
        boolean flag = false;
        while(true) {
            if(temp.getNext() == null) {
                break;
            }
            if(temp.getNext().getId() > user.getId()) {
                //找到位置，退出循环
                break;
            }else if(temp.getNext().getId() == user.getId()) {
                //重复的id
                flag = true;
                break;
            }
            temp = temp.getNext();
        }
        //开始插入数据
        if(flag) {
            System.out.println("该" +user.getId()+"的用户已经存在了");
        }else {
            user.setNext(temp.getNext());
            temp.setNext(user);
        }
    }
    
    /**
     *遍历用户
     *no 代表是那个链表
     */
    public void showList(int no) {
        User1 temp = head.getNext();
        if(temp == null) {
            System.out.println("链表"+(no+1)+"的用户为空");
            return;
        }
        System.out.println("链表"+(no+1)+"的用户为:");
        while(true) {
            if(temp== null) {
                break;
            }
            System.out.print("==>:" + temp.toString());
            temp = temp.getNext();
        }
        System.out.println();
    }
    
    /**
     * 根据id查找用户
     */
    public User1 findById(int id) {
        User1 temp = head.getNext();
        if(temp == null) {
            System.out.println();
            return null;
        }
        while(true) {
            if(temp == null) {
                temp = null;
                break;
            }
            if(temp.getId() == id) {
                break;
            }
            temp = temp.getNext();
        }
        return temp;
    }
    
    /**
     * 修改用户
     */
    public void update(User1 user) {
        User1 temp = head.getNext();
        if(temp == null) {
            System.out.println("用户不存在");
            return;
        }
        boolean flag = false;
        while(true) {
            if(temp == null) {
                break;
            }
            if(temp.getId() == user.getId()) {
                flag = true;
                break;
            }
            temp = temp.getNext();
        }
        if(flag) {
            //开始修改
            temp.setName(user.getName());
        }else {
            System.out.println("用户为空，请检查");
        }
    }
    
    /**
     * 删除用户
     */
    public void del(int id) {
        User1 temp = head;
        if(temp.getNext() == null) {
            System.out.println("用户不存在");
            return;
        }
        boolean flag = false;
        while(true) {
            if(temp.getNext() == null) {
                break;
            }
            if(temp.getNext().getId() == id) {
                flag = true;
                break;
            }
            temp = temp.getNext();
        }
        if(flag) {
            //开始修改
            temp.setNext(temp.getNext().getNext());
        }else {
            System.out.println("用户为空，请检查");
        }
    }
    
    
}

/**
 * 定义员工信息
 * @author Administrator
 *
 */
class User1{
    
    private Integer id;
    private String name;
    private User1 next;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public User1 getNext() {
        return next;
    }
    public void setNext(User1 next) {
        this.next = next;
    }
    public User1(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
}

 

煜~城
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
散列表的描述及其应用
12-28
散列表的的原理，应用，内部调用及其使用的原则
散列表及其应用
HNUYSY的博客
03-03 1772
散列表及其应用 一.散列思想 散列技术是在记录的存储位置和它的一个关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key)，根据这个确定的对应关系找到给定值key的映射f(key)，若查找集合中存在这个记录，则key必定在f(key)的位置上。 我们称这种对应关系f为散列函数，又或者称为哈希函数。按照这个思想，采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储...
散列表应用-HahMap原理讲解
南国的技术栈
11-28 384
看那这篇博文之前，首先掌握散列表的一些相关知识散列表 这篇博文很大程度上参考了HashMap实现原理及源码分析这篇博客，本文在此基础上关于jdk1.8的优化 做了一些简要叙述。 在上一篇博文中我们提到过，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突。 前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算...
散列表（哈希）应用
dzy521的博客
03-28 248
一、给出一串数以及一个数字CC，要求计算出所有A - B = CA−B=C的数对的个数（不同位置的数字一样的数对算不同的数对） 其实本题可以直接用map存 ll a[prime], n, m, ans; struct node { ll x; //当前数字（已经hash） int y; //数字出现次数 }ha[prime]; //hash表 int find(ll x) //找到x的位置 { int y = abs(x) % prime; //除法散列法（x可...
散列表基础用法
weixin_45641136的博客
03-02 84
题目： 给出N个正整数，再给出M个正整数，问这M个数中的每个数分别是否在N个数中出现过，其中N,M<=100000 #include <cstdio> const in max = 100000 bool HashTable[max] = {false}; int main(){ int n,m,x; scanf("%d %d",&n,&m); for(int i = 0; i< n;i++) { scanf("%d ",&x); HashT
散列表相关学习代码示例
03-11
8. **实际应用**：散列表广泛应用于数据库索引、缓存、字符串操作、编译器符号表等场景，它的高效查找能力使其成为解决许多问题的理想选择。 综上所述，散列表是一种高效的数据结构，通过合理的散列函数设计和冲突...
用散列表写的通讯录管理系统
04-14
在实际应用中，散列表的设计和优化也非常重要。比如，选择合适的哈希函数可以降低冲突概率；动态调整散列表大小可以应对数据量变化，保持良好的性能。此外，为了处理大量数据，有时还会采用多级散列、一致性哈希等...
散列表的原理与Java实现方法详解
08-25
理想的散列函数应该使不同的键得到不同的索引，但在实际应用中，由于键的无限多样性和有限的数组大小，可能导致不同的键映射到相同的索引，这称为碰撞。处理碰撞的方法通常有两种：开放寻址法和链地址法。Java中通常...
详解散列表算法与其相关的C语言实现
09-03
总之，散列表是通过巧妙的散列函数和冲突处理策略，提供接近O(1)的平均查找时间，广泛应用于数据库索引、缓存系统和编程竞赛等领域。理解并熟练掌握散列表的原理和C语言实现，对于提升程序性能至关重要。
散列表（HashMap）
03-07
在实际应用中，散列表可能会遇到冲突，即不同的键可能会被映射到相同的索引上。为了解决这个问题，有多种策略，其中之一就是二重散列（Double Hashing）。二重散列不是使用一个单一的散列函数，而是使用两个或多个...
哈希表的应用，介绍了一些哈希表的用例
04-07
介绍了一些哈希表的典型应用例子，对自己打基础很有帮助，哈希表是一些算法经常会用到得工具
hash表的应用
06-12
Hash表应用 （必做） （查找） [问题描述] 　　　设计散列表实现身份证查找系统，对身份证号进行Hash。 [基本要求] （1） 设每个记录有下列数据项：身份证号码（虚构，位数和编码规则与真实一致即可）、姓名、地址； （2） 从键盘或文件输入各记录，以身份证号码为关键字建立散列表； （3） 采用开放定址的方法解决冲突； （4） 查找并显示给定身份信息的记录； 自备身份证信息文件
Redis散列表(hash)使用
蜗牛学习笔记
02-05 4389
Redis的散列(hash)表会将一个键和一个散列表在数据库中关联起来，用户可以在散列表中为任意多个字设置值。与字符键一样，散列的字段和值既可以是文本数据，可以是二进制数据。 通过使用散列表，用户可以把相关联的多项数据存储到同一个散列里面，以便对这些数据进行管理，或者针对他们进行批量操作。 与之前使用字符串键存储文章数据的做法相比，使用散列存储文章数据只需要在数据库里面创建一个键，并且因为散列的字段名不需添加任何前缀，所以他们可以直接反映字段值存储的是什么数据。Redis为散列舰提供了一
散列表的原理和应用
阿不灌的拉的博客
08-13 1820
本来以为，散列表就是map，今天做了道题看答案的时候，才发现我原来搞错了，于是简单的学习了一下散列表的原理和简单实现，发博客分享一下～ 我们知道，数组的动态操作（删除、插入）是非常耗时的，链表的静态操作（查找）也是颇为麻烦的。 在既涉及静态操作，又涉及动态操作的场合，这两种基本的数据结构就非常乏力了。 如何达到平衡呢？ 我们想象一个场景，在一个特殊的学校里，一开始并没有班级的概念，几千名学...
哈希表（hash table）及其应用举例
03-29 1296
哈希表最主要的有点在于我们利用它能够在 O(1)O(1) 时间查找某一元素，是效率最高的查找方式，其缺点是需要额外的空间实现哈希表。
hash table原理与应用
微小的鱼的博客
12-19 350
散列表,它是基于快速存取的角度设计的，也是一种典型的“空间换时间”的做法。顾名思义，该数据结构可以理解为一个线性表，但是其中的元素不是紧密排列的，而是可能存在空隙。散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
散列表原理及其应用
Alan-zzx的博客
11-21 332
给定若干非负整数，范围是1~10000，编写程序使得查询一个数的时间复杂度为O(1)。 int data[10001]; void insert(int key){ data[key] = key; } int search(int key){ return data[key]; } 上述代码的基本思想是将每个输入的key，存放在数组的key这个位置。 我们假设数组下标为a，对应位置的值为...
散列查找-（六）应用实例
eeeemon的博客
11-17 381
（一）入门理解 （二）基本概念 （三）散列函数的构造方法 （四）处理冲突的方法 （五）散列表的性能分析 （六）应用实例 输入小说的文字，统计所有单词出现的次数
hash和散列表在java中的作用
qq_33330524的博客
12-20 373
散列表/哈希表是存储记录的数据结构，哈希函数是关键字和存储位置的对应关系的映射函数，我们希望f(Key)得到不同哈希地址。但是一般总会有冲突存在。key是关键字的话，是由字母数字组成的，大约1.2x10^14,而实际中用不到那么多，哈希函数就是一个压缩映像。 Hash关键在于hash函数的选择和冲突解决。 好的hash函数是均匀的，就是尽量不要映射后存储位置聚集。 冲突解决当然很多，最常用的是开放...
数据结构课程设计：散列表与旅游交通查询系统的应用
""数据结构课程设计(基于散列表的程序相近度检测系统和旅游交通查询系统)" 本课程设计涵盖了两个项目：基于散...通过这样的课程设计，学生可以深入理解数据结构如何在实际应用中发挥作用，提升自己的编程和分析技能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值