Java_Map_Set

文章目录

  • 一、搜索树
    • 1.概念
    • 2.操作-查找
    • 3.操作-插入
    • 4.操作-删除（难点）
    • 5.完整代码
  • 二、搜索
    • 1.概念及场景
    • 2.模型
  • 三、Map的使用
    • 1.Map的常用方法说明
  • 四、Set的使用
    • 1.常见方法说明
    • 2.TreeSet的使用案例
  • 五、哈希表
    • 1.概念
    • 2.哈希冲突
    • 3.哈希冲突避免
    • 4.哈希冲突的避免-哈希函数设计
    • 5.哈希冲突的避免-负载因子调节
    • 6.哈希冲突解决-闭散列
    • 7.哈希冲突解决-开散列/哈希桶
    • 8.HashCode
    • 9. 模拟实现

在这里插入图片描述
Map和Set要解决是搜索问题，TreeSet和TreeMap背后是一个棵搜索树，这棵搜索树是红黑树。接下来学习过程是搜索树-》平衡二叉树-》红黑树。

一、搜索树

1.概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

在这里插入图片描述
{5,3,4,1,7,8,2,6,0,9};
这棵树的中序遍历的结果是有序的。

搜索二叉树代码框架：

public class BinarySearchTree {static class TreeNode{public int val;public TreeNode left;public TreeNode right;public TreeNode(int val){this.val =val;}}public TreeNode root ;
}

2.操作-查找

在这里插入图片描述

    public Boolean search(int key){TreeNode cur = root;while(cur!=null){if(cur.val<key){cur = cur.right;}else if(cur.val>key){cur = cur.left;}else{return true;}}return false;}

3.操作-插入

1、如果树为空，即根==null,直接插入
在这里插入图片描述
2、如果树不是空树，按照查找逻辑确定插入位置，插入新结点

在这里插入图片描述

    public  boolean insert(int val){if(root==null){root  = new TreeNode(val);return true;}TreeNode cur = root;TreeNode parent =null;while(cur!=null){if(cur.val<val){parent =cur;cur = cur.right;}else if(cur.val>val) {parent = cur;cur = cur.left;}else {return false;}}if(parent.val<val){parent.right = new TreeNode(val);}else{parent.left = new TreeNode(val);}return true;}

4.操作-删除（难点）

设待删除结点为 cur, 待删除结点的双亲结点为 parent

  1. cur.left == null
    1. cur 是 root，则 root = cur.right
    2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.right
    3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.right
  2. cur.right == null
    1. cur 是 root，则 root = cur.left
    2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.left
    3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.left
  3. cur.left != null && cur.right != null
    1. 需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题
    public  boolean remove(int key){TreeNode cur = root;TreeNode parent =null;while(cur!=null){if(cur.val>key){parent = cur;cur =cur.left;}else if(cur.val<key){parent = cur;cur = cur.right;}else{//开始删除if(cur.left==null){if(parent==null){root = cur.right;}else{if(cur==parent.left){parent.left = cur.right;}else {parent.right = cur.left;}}}else  if(cur.right==null){if(parent==null){root = cur.left;}else{if(cur==parent.left){parent.left = cur.left;}else {parent.right = cur.left;}}}else{TreeNode targetParent = cur;TreeNode target = cur.right;while(target.left!=null){targetParent = target;target = target.left;}cur.val =target.val;if(targetParent.left ==target){targetParent.left = target.right;}else{targetParent.right = target.right;}}return  true;}}return  false;}}

5.完整代码

public class BinarySearchTree {static class TreeNode{public int val;public TreeNode left;public TreeNode right;public TreeNode(int val){this.val =val;}}public TreeNode root ;public Boolean search(int key){TreeNode cur = root;while(cur!=null){if(cur.val<key){cur = cur.right;}else if(cur.val>key){cur = cur.left;}else{return true;}}return false;}public  boolean insert(int val){if(root==null){root  = new TreeNode(val);return true;}TreeNode cur = root;TreeNode parent =null;while(cur!=null){if(cur.val<val){parent =cur;cur = cur.right;}else if(cur.val>val) {parent = cur;cur = cur.left;}else {return false;}}if(parent.val<val){parent.right = new TreeNode(val);}else{parent.left = new TreeNode(val);}return true;}public  boolean remove(int key){TreeNode cur = root;TreeNode parent =null;while(cur!=null){if(cur.val>key){parent = cur;cur =cur.left;}else if(cur.val<key){parent = cur;cur = cur.right;}else{//开始删除if(cur.left==null){if(parent==null){root = cur.right;}else{if(cur==parent.left){parent.left = cur.right;}else {parent.right = cur.left;}}}else  if(cur.right==null){if(parent==null){root = cur.left;}else{if(cur==parent.left){parent.left = cur.left;}else {parent.right = cur.left;}}}else{TreeNode targetParent = cur;TreeNode target = cur.right;while(target.left!=null){targetParent = target;target = target.left;}cur.val =target.val;if(targetParent.left ==target){targetParent.left = target.right;}else{targetParent.right = target.right;}}return  true;}}return  false;}}

二、搜索

1.概念及场景

Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。
可能在查找时进行一些插入和删除的操作，即动态查找，Map和Set是一种适合动态查找的集合容器。

2.模型

一般把搜索的数据称为关键字（Key），和关键字对应的称为值（Value），将其称之为Key-value的键值对，所以模型会有两种：

  1. 纯 key 模型，比如：
    有一个英文词典，快速查找一个单词是否在词典中
    快速查找某个名字在不在通讯录中
  2. Key-Value 模型，比如：
    统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>
    梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号
    而Map中存储的就是key-value的键值对，Set中只存储了Key。

三、Map的使用

    public static void main(String[] args) {Map<String,Integer> map1  = new TreeMap<>();//查找时间复杂度O(logn)Map<String,Integer> map2  =new HashMap<>();//查找时间复杂度O(1)}

1.Map的常用方法说明

方法解释
V get(Object key)返回 key 对应的 value
V getOrDefault(Object key, V defaultValue)返回 key 对应的 value，key 不存在，返回默认值
V put(K key, V value)设置 key 对应的 value
V remove(Object key)删除 key 对应的映射关系
Set keySet()返回所有 key 的不重复集合
Collection values()返回所有 value 的可重复集合
Set<Map.Entry<K, V>> entrySet()返回所有的 key-value 映射关系
boolean containsKey(Object key)判断是否包含 key
boolean containsValue(Object value)判断是否包含 value
    public static void main(String[] args) {Map<String,Integer> map1  = new TreeMap<>();//查找时间复杂度O(logn)map1.put("abc",1);map1.put("def",2);map1.put("ghj",3);//通过key获取val值Integer val = map1.get("def");Integer val2 = map1.get("defg");Integer val3 = map1.getOrDefault("abcd",-1);System.out.println(val);System.out.println(val2);System.out.println(val3);System.out.println("==========");map1.remove("abc");Integer val4 = map1.get("abc");System.out.println(val4);System.out.println("==========");Set<String>  set = new TreeSet<>();set = map1.keySet();System.out.println(set);System.out.println("==========");map1.put("abc",2);Collection<Integer> array  = new ArrayList<>();array = map1.values();System.out.println(array);System.out.println("==========");Set<Map.Entry<String ,Integer>> entrySet = map1.entrySet();for(Map.Entry<String,Integer> e:entrySet){System.out.println("key:"+e.getKey()+"  val:"+e.getValue());}System.out.println("==========");System.out.println(map1.containsKey("abc"));System.out.println(map1.containsKey("abcd"));System.out.println(map1.containsValue(1));System.out.println(map1.containsValue(2));//        Map<String,Integer> map2  =new HashMap<>();//查找时间复杂度O(1)}

在这里插入图片描述

  1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
  2. Map中存放键值对的Key是唯一的，value是可以重复的
  3. 在TreeMap中插入键值对时，key不能为空，否则就会抛NullPointerException异常，value可以为空。但是HashMap的key和value都可以为空。
  4. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
  5. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
  6. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。

四、Set的使用

1.常见方法说明

方法解释
boolean add(E e)添加元素，但重复元素不会被添加成功
void clear()清空集合
boolean contains(Object o)判断 o 是否在集合中
Iterator iterator()返回迭代器
boolean remove(Object o)删除集合中的 o
int size()返回set中元素的个数
boolean isEmpty()检测set是否为空，空返回true，否则返回false
Object[] toArray()将set中的元素转换为数组返回
boolean containsAll(Collection<?> c)集合c中的元素是否在set中全部存在，是返回true，否则返回false
boolean addAll(Collection<? extends E> c)将集合c中的元素添加到set中，可以达到去重的效果
注意：
  1. Set是继承自Collection的一个接口类
  2. Set中只存储了key，并且要求key一定要唯一
  3. TreeSet的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
  4. Set最大的功能就是对集合中的元素进行去重
  5. 实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在HashSet的基础
    上维护了一个双向链表来记录元素的插入次序。
  6. Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入
  7. TreeSet中不能插入null的key，HashSet可以。

2.TreeSet的使用案例

    public static void main(String[] args) {Set<String> set = new TreeSet<>();set.add("sunny");set.add("hello");set.add("the");System.out.println(set);System.out.println("==========");Iterator<String> iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}}

在这里插入图片描述

五、哈希表

1.概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素

根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素

对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若
关键码相等，则搜索成功

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)
例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
在这里插入图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快 问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

2.哈希冲突

哈希冲突（哈希碰撞）：不同的关键字KEY，通过相同的哈希函数得到了相同的值。
对于两个数据元素的关键字 和 (i != j)，有 != ，但有Hash(ki) == Hash( kj)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词“。

3.哈希冲突避免

首先，我们需要明确一点，由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率。

4.哈希冲突的避免-哈希函数设计

引起哈希冲突的一个原因可能是**：哈希函数设计不够合理。 哈希函数设计原则**：
哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
哈希函数计算出来的地址能均匀分布在整个空间中
哈希函数应该比较简单

常见哈希函数

  1. 直接定制法
    取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况
  2. 除留余数法
    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：
    Hash(key) = key% p(p<=m),将关键码转换成哈希地址

5.哈希冲突的避免-负载因子调节

散列表的载荷因子定义为a = 填入表中的元素个数 / 散列表的长度
负载因子和冲突率的关系粗略演示
在这里插入图片描述
所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

6.哈希冲突解决-闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？

  1. 线性探测
    比如上面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
    线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
    插入
    通过哈希函数获取待插入元素在哈希表中的位置
    如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到
    下一个空位置，插入新元素
    在这里插入图片描述
  2. 二次探测
    线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： Hi= ( H0+ i^2)% m, 或者：Hi= ( H0- i^2)% m。其中：i = 1,2,3…为冲突次数， H0是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，
    m是表的大小。 中如果要插入4,44,14，产生冲突，使用解决后的情况为：
    在这里插入图片描述
    44:(4+1）%10 = 5
    14:(4+4)%10 = 8
    因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

7.哈希冲突解决-开散列/哈希桶

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在这里插入图片描述

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。
开散列，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了。

8.HashCode

hashCode就是对象的散列码，是根据对象的某些信息推导出的一个整数值，默认情况下表示是对象的存储地址。通过散列码，可以提高检索的效率，主要用于在散列存储结构中快速确定对象的存储地址。

package demo1;import java.util.Map;class Student{public String id ;public Student(String id) {this.id = id;}
}
public class Test {public static void main(String[] args) {Map<Student,Integer> map;Student student1 = new Student("123456");Student student2 = new Student("123456");//不重写HashCodeSystem.out.println(student1.hashCode());System.out.println(student2.hashCode());}
}

在这里插入图片描述

重写HashCode根据id:

package demo1;import java.util.Map;
import java.util.Objects;class Student{public String id ;public Student(String id) {this.id = id;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return Objects.equals(id, student.id);}@Overridepublic int hashCode() {return Objects.hash(id);}
}
public class Test {public static void main(String[] args) {Map<Student,Integer> map;Student student1 = new Student("123456");Student student2 = new Student("123456");//重写HashCodeSystem.out.println(student1.hashCode());System.out.println(student2.hashCode());}
}

在这里插入图片描述

9. 模拟实现

package demo1;public class HashBuck <K,V>{static class Node<K,V> {public K key;public V val;public Node<K,V> next;public  Node(K key,V val){this.key = key;this.val =val;}}public Node<K,V> [] array;public int  usedSize;public static final float DEFAULT_LOAD_FACTOR = 0.75f;public HashBuck(){array = (Node<K,V>[])new Node[10];}public void put(K key ,V val){int hash = key.hashCode();int index = hash%array.length;Node<K,V> cur = array[index];while(cur!=null){if(cur.key.equals(key)){cur.val = val;return;}else{cur = cur.next;}}Node<K,V> newNode = new Node<>(key,val);newNode.next = array[index];array[index] = newNode;usedSize++;}public V getValue(K key){int hash = key.hashCode();int index = hash%array.length;Node<K,V> cur = array[index];while(cur!=null){if(cur.key.equals(key)){return cur.val;}else{cur =cur.next;}}return  null;}
}

测试代码：

    public static void main(String[] args) {HashBuck<Student,Integer> hashBuck =new HashBuck<>();Student student1 = new Student("123");Student student2 = new Student("456");Student student3 = new Student("123");hashBuck.put(student1,123);hashBuck.put(student2,456);System.out.println(hashBuck.getValue(student3));}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/526865.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

爬虫练习：获取某网站的房价信息

爬虫练习：获取某网站的房价信息

一、相关网站 二、相关代码 import requests from lxml import etree import csv with open(房天下数据.csv, w, newline, encodingutf-8) as csvfile:fieldnames [名称, 地点,价格,总价,联系电话]writer csv.DictWriter(csvfile, fieldnamesfieldnames)writer.writeheader…
阅读更多...
【解读】OWASP大语言模型应用程序十大风险

【解读】OWASP大语言模型应用程序十大风险

OWASP大型语言模型应用程序前十名项目旨在教育开发人员、设计师、架构师、经理和组织在部署和管理大型语言模型&#xff08;LLM&#xff09;时的潜在安全风险。该项目提供了LLM应用程序中常见的十大最关键漏洞的列表&#xff0c;强调了它们的潜在影响、易利用性和在现实应用程序…
阅读更多...
学习和认知的四个阶段，以及学习方法分享

学习和认知的四个阶段，以及学习方法分享

本文分享学习的四个不同的阶段&#xff0c;以及分享个人的一些学习方法。 一、学习认知的四个阶段 我们在学习的过程中&#xff0c;总会经历这几个阶段&#xff1a; 第一阶段&#xff1a;不知道自己不知道&#xff1b; 第二阶段&#xff1a;知道自己不知道&#xff1b; 第三…
阅读更多...
数据结构详解①——诸论

数据结构详解①——诸论

目录 前言 引入&#xff1a; 基本概念和术语 数据 数据元素 数据项 数据对象 数据结构 逻辑结构 物理结构 数据类型 为什么要设计出来数据类型呢&#xff1f; 数据类型的分类 抽象数据类型 数据结构与算法的关系 算法 定义 特性 设计要求 效率度量方法 事…
阅读更多...
DataGrip 2023：让数据库开发变得更简单、更高效 mac/win

DataGrip 2023：让数据库开发变得更简单、更高效 mac/win

JetBrains DataGrip 2023是一款功能强大的数据库IDE&#xff0c;专为数据库开发和管理而设计。通过DataGrip&#xff0c;您可以连接到各种关系型数据库管理系统(RDBMS)&#xff0c;并使用其提供的一组工具来查询、管理、编辑和开发数据库。 DataGrip 2023软件获取 DataGrip 2…
阅读更多...
牛客小白月赛88（A,B,C,D,E,F,G）

牛客小白月赛88（A,B,C,D,E,F,G）

这场神中神&#xff0c;题型都很新&#xff0c;学到了很多。比赛链接&#xff0c;官方视频讲解&#xff0c;出题人题解 这场官方讲解我觉得讲的还是很好的。 D是个不太裸的DP&#xff0c;是01背包的变种。 E有三种做法&#xff0c;在前两天的abc&#xff08;atcoder beginne…
阅读更多...
Objects类 --java学习笔记

Objects类 --java学习笔记

Objects类 Objects是一个工具类&#xff0c;提供了很多操作对象的静态方法给我们使用 Objects类常用的三个方法 Objects.equals 比直接equals更安全&#xff0c;因为Objects.equals里面做了非空校验 Objects.isNull&#xff08;A&#xff09; 等价于 A null Objects.non…
阅读更多...
SpringCloud-Alibaba-Nacos教程

SpringCloud-Alibaba-Nacos教程

SpringCloud-Alibaba-Nacos教程 下载地址 https://github.com/alibaba/nacos/releases/tag/2.2.3 直接进入bin包 运行cmd命令 startup.cmd -m standalone 运行成功后 进入nacos可视化页面 账号密码默认都是nacos http://localhost:8848/nacos 微服务入驻Nacos服务注册…
阅读更多...
011-keep-alive详解

011-keep-alive详解

keep-alive详解 1、简介2、keep-alive的使用效果未使用keep-alive的效果图使用keep-alive的效果图include和exclude指定是否缓存某些组件使用keep-alive的钩子函数执行顺序问题 3、keep-alive的应用场景举例4、总结 1、简介 keep-alive 是 Vue 的内置组件&#xff0c;当它包裹…
阅读更多...
win10阿里云实现内网穿透#frp

win10阿里云实现内网穿透#frp

win10&阿里云实现内网穿透#frp 文章目录 win10&阿里云实现内网穿透#frp一、什么是内网穿透&#xff1f;下载frp 二、云服务端部署frps三、本地部署frpc 一、什么是内网穿透&#xff1f; 内网穿透是一种网络技术&#xff0c;它允许外部网络用户通过互联网访问局域网&am…
阅读更多...
【Django开发】0到1美多商城项目md教程第1篇：欢迎来到美多商城！【附代码文档】

【Django开发】0到1美多商城项目md教程第1篇：欢迎来到美多商城！【附代码文档】

本系列文章md笔记&#xff08;已分享&#xff09;主要讨论django商城项目相关知识。项目利用Django框架开发一套前后端不分离的商城项目&#xff08;4.0版本&#xff09;含代码和文档。功能包括前后端不分离&#xff0c;方便SEO。采用Django Jinja2模板引擎 Vue.js实现前后端…
阅读更多...
亚马逊跨境电商名词解释

亚马逊跨境电商名词解释

亚马逊界面名词解释 最常用的名词解释总结&#xff1a; ASIN&#xff1a;亚马逊标准标识号,也就是每个商品的编码标识,每个商品的都不同&#xff0c;可以把它当成该商品的“身份证号”。由亚马逊随机生成的字母数字组合。 SKU&#xff1a;库存进出计量单位。 Listing&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023