数据结构入门（java版）（十四）

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

哈希表的实现

每一个字符都和一个索引相对应

哈希函数的设计：

整型：

小范围正整数直接用

小范围负数：进行偏移

大整数：取模

摸一个素数，解决分布不均

浮点型：将浮点数占用的空间转化为整型处理

字符串：转化为整型处理

java中的hashcode

哈希冲突的处理：Seperate chaining

其他方法，开放地址法，只要扩容的量是合适的，则时间复杂度为O(1)

在java中HashCode的实现：

public class Student {

    int grade;
    int cls;
    String firstName;
    String lastName;

    Student(int grade, int cls, String firstName, String lastName){

        this.grade = grade;
        this.cls = cls;
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    //  java自带的hashCode是根据地址来进行的映射
    // 如果没有自定义，则可能出现不想要的情况
    public int hashCode(){


        /*
        类似计算进制数
        hash = ( ( (grade * B) + cls ) * B + firstName ) *B + lastName )
         */
        int B = 31;

        int hash = 0;
        hash = hash *B +grade;
        hash = hash *B + cls;
        hash = hash *B + firstName.toLowerCase().hashCode();
        hash = hash *B + lastName.toLowerCase().hashCode();

        return hash;   // 转换为一个整型
    }

    @Override

    // 比较这两个对象是否相同
    public boolean equals(Object o){

        if (this == o)
            return true;

        if (o == null)
            return false;

        if (getClass() != o.getClass())
            return false;

        Student another = (Student)o;

        return this.grade == another.grade &&
                this.cls == another.cls &&
                this.firstName.toLowerCase().equals(another.firstName.toLowerCase()) &&
                this.lastName.toLowerCase().equals(another.lastName.toLowerCase());
    }

}

哈希表的实现：
***第一种***使用定长数组实现

import java.util.TreeMap;

public class HashTable<K, V> {

    private TreeMap[] hashtable;
    private int M;   // 哈希表长度,数组长度
    private int size;   // 已经存储的数

    public HashTable(int M){
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];

        for (int i = 0; i < M; i ++)
            hashtable[i] = new TreeMap<>();
    }

    public HashTable(){
        this(97);
    }

    // 求哈希值,将传入的值映射为表中的索引
    private int hash(K key){
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize(){
        return size;
    }

    // 添加一个（key， value）的map
    public void add(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        // 当成传入到二分搜索树的一个头节点中

        if (map.containsKey(key))
            map.put(key, value);
        else{
            map.put(key, value);
            size ++;
        }
    }

    // 移除key对应的值
    public V remove(K key){

        TreeMap<K, V> map = hashtable[hash(key)];
        V ret = null;

        if (map.containsKey(key)){
            ret = map.remove(key);
            size --;
        }

        return ret;
    }


    // 修改key对应的值
    public void set(K key, V value){

        TreeMap<K, V> map = hashtable[hash(key)];

        if (!map.containsKey(key))
            throw new IllegalArgumentException(key + "doesn`t exist!");

        map.put(key, value);
    }

    // 是否存在某一个key
    public boolean contains(K key){
        return hashtable[hash(key)].containsKey(key);
    }

    // 获得key对应的value
    public V get(K key){
        return (V) hashtable[hash(key)].get(key);
    }


}

***第二种***使用动态数组的方式实现

import java.util.TreeMap;

// 使用动态数组的方式对哈希表进行动态空间处理
public class HashTable2<K, V> {

    private static final int upperTol = 10;   // 扩容的上界
    private static final int lowerTol = 2;   // 缩容的下界
    private static final int initCapacity = 7;   // 初始的容量大小


    private TreeMap[] hashtable;
    private int M;   // 哈希表长度,数组长度
    private int size;   // 已经存储的数

    public HashTable2(int M){
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];

        for (int i = 0; i < M; i ++)
            hashtable[i] = new TreeMap<>();
    }

    public HashTable2(){
        this(initCapacity);
    }

    // 求哈希值,将传入的值映射为表中的索引
    private int hash(K key){
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize(){
        return size;
    }

    // 添加一个（key， value）的map
    public void add(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        // 当成传入到二分搜索树的一个头节点中

        if (map.containsKey(key))
            map.put(key, value);
        else{
            map.put(key, value);
            size ++;

            if (size >= upperTol * M)
                resize(2 * M);
        }
    }

    // 移除key对应的值
    public V remove(K key){

        TreeMap<K, V> map = hashtable[hash(key)];
        V ret = null;

        if (map.containsKey(key)){
            ret = map.remove(key);
            size --;

            if (size < lowerTol * M && M / 2 >= initCapacity)
                resize(M / 2);
        }

        return ret;
    }


    // 修改key对应的值
    public void set(K key, V value){

        TreeMap<K, V> map = hashtable[hash(key)];

        if (!map.containsKey(key))
            throw new IllegalArgumentException(key + "doesn`t exist!");

        map.put(key, value);
    }

    // 是否存在某一个key
    public boolean contains(K key){
        return hashtable[hash(key)].containsKey(key);
    }

    // 获得key对应的value
    public V get(K key){
        return (V) hashtable[hash(key)].get(key);
    }

    private void resize(int newM){

        TreeMap<K, V>[] newHashTable = new TreeMap[newM];

        for (int i = 0; i < newM; i ++)
            newHashTable[i] = new TreeMap<>();

        int oldM = M;   // 原来数组的大小
        this.M = newM;   // 新数组的大小

        for (int i = 0; i < oldM; i ++){
            TreeMap<K, V> map = hashtable[i];

            for (K key : map.keySet())
                newHashTable[hash(key)].put(key, map.get(key));
        }

        this.hashtable = newHashTable;
    }


}

***第三种***在动态数组中每次扩容和缩容按照一定的大小进行，按照右图这样的顺序：

在这里插入图片描述

实现代码：

import java.util.TreeMap;

// 使用动态数组的方式对哈希表进行动态空间处理，使得每次扩容都是一个素数
public class HashTable3<K, V> {

    private final int[] capacity = {
            13,   19,   29,   41,   59,   79,   107,   149,   197,   263,   347,   457,   599,   787,   1031,
            1361,   1777,   2333,   3037,   3967,   5167,   6719,   8737,   11369,   14783,
            19219,   24989,   32491,   42257,   54941,   71429,   92861,   120721,   156941,
            204047,   265271,   344857,   448321,   582821,   757693,   985003,   1280519,
            1664681,   2164111,   2813353,   3657361,   4754591,   6180989,   8035301,
            10445899,   13579681,   17653589,   22949669,   29834603,   38784989,
            50420551,   65546729,   85210757,   110774011,   144006217,   187208107,
            243370577,   316381771,   411296309,   534685237,   695090819,   903618083,
            1174703521,   1527114613,   1837299131,   2147483647
    };   // 扩容或缩容的变化值

    private static final int upperTol = 10;   // 扩容的上界
    private static final int lowerTol = 2;   // 缩容的下界
    private int capacityIndex = 0;   // 初始的容量的索引


    private TreeMap[] hashtable;
    private int M;   // 哈希表长度,数组长度
    private int size;   // 已经存储的数

    public HashTable3(){
        this.M = capacity[capacityIndex];
        size = 0;
        hashtable = new TreeMap[M];

        for (int i = 0; i < M; i ++)
            hashtable[i] = new TreeMap<>();
    }


    // 求哈希值,将传入的值映射为表中的索引
    private int hash(K key){
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize(){
        return size;
    }

    // 添加一个（key， value）的map
    public void add(K key, V value){
        TreeMap<K, V> map = hashtable[hash(key)];
        // 当成传入到二分搜索树的一个头节点中

        if (map.containsKey(key))
            map.put(key, value);
        else{
            map.put(key, value);
            size ++;

            if (size >= upperTol * M && capacityIndex +1 < capacity.length){
                capacityIndex ++;
                resize(capacity[capacityIndex]);
            }
        }
    }

    // 移除key对应的值
    public V remove(K key){

        TreeMap<K, V> map = hashtable[hash(key)];
        V ret = null;

        if (map.containsKey(key)){
            ret = map.remove(key);
            size --;

            if (size < lowerTol * M && capacityIndex - 1 >= 0) {
                capacityIndex --;
                resize(capacity[capacityIndex]);
            }
        }

        return ret;
    }


    // 修改key对应的值
    public void set(K key, V value){

        TreeMap<K, V> map = hashtable[hash(key)];

        if (!map.containsKey(key))
            throw new IllegalArgumentException(key + "doesn`t exist!");

        map.put(key, value);
    }

    // 是否存在某一个key
    public boolean contains(K key){
        return hashtable[hash(key)].containsKey(key);
    }

    // 获得key对应的value
    public V get(K key){
        return (V) hashtable[hash(key)].get(key);
    }

    private void resize(int newM){

        TreeMap<K, V>[] newHashTable = new TreeMap[newM];

        for (int i = 0; i < newM; i ++)
            newHashTable[i] = new TreeMap<>();

        int oldM = M;   // 原来数组的大小
        this.M = newM;   // 新数组的大小

        for (int i = 0; i < oldM; i ++){
            TreeMap<K, V> map = hashtable[i];

            for (K key : map.keySet())
                newHashTable[hash(key)].put(key, map.get(key));
        }

        this.hashtable = newHashTable;
    }


}
Neo的作战室
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
【数据结构和算法】入门初识篇
weixin_60719453的博客
11-08 2436
目录 一、前言 二、数据结构的理解 物理结构和逻辑结构 1.逻辑结构 2. 物理结构 一、前言 我们前面我学了Java的内部类，现在来学习一下数据结构和算法，多科齐下不仅可以 学科交插学习互相帮助，还可以锻炼跳跃性思维。 二、数据结构的理解 数据元素存在的一种或多种关系的集合。 程序设计=数据结构+算法 物理结构和逻辑结构 逻辑结构：数据对象之间的关系，各元素之间的关系。 物理结构：计算机中的存储的关系。 1.逻辑结构 包括集合结构、线性结构、树形结构、图形结
【入门必备】Java数据结构详解
weixin_62633072的博客
03-15 9158
数据结构入门必看！本文整理了稀疏数组、队列、链表、栈这几种经典的数据结构。快来一起敲代码吧！！！
Java中常用数据结构及方法
Liususiu的秃头日记
12-18 2907
记录总结Java中常用的结构和方法。
Java数据结构的实现
m0_43405302的博客
10-28 1818
一、Java数据结构 众所周知，数据结构是算法的基础。从事程序设计工作的人来说，我们在日常编程的编程过程中，我们都会有意无意的接触到一些数据结构和算法的知识。为了能够更好的对于程序进行优化，所以数据结构相关的知识必须有所了解。学完了Java面向对象的基础知识后，我们可以更深入的了解Java数据结构算法的基础知识，进而提高我们的编程思维和解决问题的思路。接下来，我将介绍Java数据结构相关的知识。 二、Java数组 Java数据是我们入门学的第一个最基本的数据结构，这是一个常用的线性储存结构。 1、初始化数组
java数据结构-栈
小赵的呢
02-18 6410
栈 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的常见基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：判断一个栈是否为空，若栈为空则返回t
Java数据结构与算法入门
qq_37101453的博客
04-29 3万+
第一部分：Java数据结构要理解Java数据结构，必须能清楚何为数据结构？数据结构:Data_Structure，它是储存数据的一种结构体，在此结构中储存一些数据，而这些数据之间有一定的关系。而各数据元素之间的相互关系，又包括三个组成成分，数据的逻辑结构，数据的存储结构和数据运算结构。而一个数据结构的设计过程分成抽象层、数据结构层和实现层。数据结构在Java的语言体系中按逻辑结构可以分为两大类：线...
使用Java实现顺序表（数据结构入门）
qq_41379860的博客
10-20 4570
使用Java实现顺序表（数据结构入门） 最近在学数据结构，但是学校要求的是用c语言来写，我之前c语言学的不好，只是会一点点Java。所以恶补了几天的c慢慢的有了自己的思路。昨天晚上睡觉的时候突然有个想法：能不能用Java写一下顺序表的实现呢。说干就干，早上一起床就打开电脑敲起了代码。 什么是顺序表 顺序表是指用一组地址连续的存储单元依次存储各个元素， 使得在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中的线性表。 然后代码如下（第一次写有点紧张qaq）： 初始化顺序表 private int len;
数据结构—树(Tree)的入门原理以及Java实现案例
终生学习践行者
04-23 1万+
详细介绍了树这种数据结构的基本概念，以及通用的树的Java实现方式，为后面各种树的深入学习打好基础。
Java 入门 （超级详细）
热门推荐
qq_63519395的博客
11-21 4万+
Java是一种高级编程语言，由Sun Microsystems公司于1995年推出。Java具有跨平台性、面向对象、健壮性、安全性、可移植性等特点，被广泛应用于企业级应用开发、移动应用开发、大数据处理、云计算等领域。Java程序可以在不同的操作系统上运行，只需编译一次，就可以在任何支持Java虚拟机（JVM）的平台上运行。Java还提供了丰富的库和框架，可以加快开发过程，提高开发效率。变量是计算机程序中用于存储数据的一种数据类型。它是一个名称，代表了一个值或一个对象，可以在程序中多次使用。
数据结构（java版本）
05-27
总的来说，《数据结构（Java版本）》是一本适合程序员入门的教材，通过学习，你可以系统地掌握数据结构和算法，并用Java语言进行实现，为今后的软件开发打下坚实的基础。无论你是准备面试，还是想要提升编程技能，这...
数据结构java版
09-21
本资源"数据结构java版"是一个适合学生党的入门教程，旨在帮助初学者了解并实践Java语言实现的数据结构。 首先，我们需要理解数据结构的基本类型。这些包括数组、链表、栈、队列、散列表、树和图等。数组是最基础的...
Java 数据结构
01-03
Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类： 枚举（Enumeration） 位集合（BitSet） 向量（Vector） 栈（Stack） 字典（Dictionary） 哈希表（Hashtable） 属性...
java数据结构和算法中数组的简单入门
08-25
Java数据结构和算法中数组的简单入门 在 Java 数据结构和算法中，数组是最基本也是最重要的一种数据结构。数组是一种固定长度的数据集合，可以存储同类型的数据元素。下面是关于 Java 数组的简单入门知识点： 一、...
Pandas_数据结构详解
2201_75415080的博客
09-19 1263
DataFrame是一个表格型的==结构化==数据结构，它含有一组或多组有序的列（Series），每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame是Pandas中最基本的数据结构，Series的许多属性和方法在DataFrame中也一样适用.两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。
Python中的树与图：构建复杂数据结构的艺术
最新发布
qq_44771627的博客
09-20 629
随着大数据时代的到来，我们面临的数据不再是简单的线性关系，而是错综复杂的网状结构。树和图正是用于表示这类复杂关系的最佳工具。树是一种特殊的图，它具有层次结构；而图则更加灵活，能够表达任意节点之间的连接关系。掌握树与图的实现方法，不仅有助于提高算法设计能力，还能为解决现实世界的问题提供新的视角。
数据结构——二叉搜索树、Map和Set
zhakakqns的博客
09-18 843
对于不同的数据结构，他们的使用场景是不一样的，map和set这两种数据结构主要用在搜索相关的场景中。学习这些之前我们先来了解一下二叉搜索树，
【数据结构】经典题
2402_85428625的博客
09-17 427
定义：非线性结构是指数据元素之间存在一对多或多对多的关系，数据元素在逻辑上不是线性排列的。定义：线性结构是指数据元素之间存在一对一的关系，数据元素在逻辑上是线性排列的。所以，语句 x++;的语句频度为：n(n+1)(n+2）/6 选C。没有使用额外的数组：所有的操作都是在原数组 a 上进行的。临时变量 t：只使用了一个额外的变量来存储交换的值。健壮的算法不会因非法的输入数据而出现莫名其妙的状态。因此，算法的空间复杂度是常数级别的，即 O(1)。例子：数组、链表、栈、队列等。数据元素之间的关系更加复杂。
数据结构——LeetCode刷题:7. 整数反转,66. 加一,1. 两数之和
u014114223的博客
09-19 1032
你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。你可以假设除了整数 0 之外，这个整数不会以零开头。最高位数字存放在数组的首位， 数组中每个元素只存储。如果反转后整数超过 32 位的有符号整数的范围。数组所表示的非负整数，在该数的基础上加一。给你一个 32 位的有符号整数。整数，并返回它们的数组下标。中的数字部分反转后的结果。你可以按任意顺序返回答案。，请你在该数组中找出。
Java版数据结构与算法分析入门指南
"数据结构与算法分析(Java版)"是一本由Robert Lafore编著的书籍，专注于使用Java语言探讨和实现数据结构与算法。书中的内容涵盖了从基础到高级的数据结构和算法，旨在帮助读者利用Java有效地操纵数据。 在本书中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值