• Map和Set

    目录

    1.二叉搜索树

    2.搜索

    （1）概念及场景

    （2）模型

    3.Map

    （1）特点

    （2）常用方法

    （3）遍历Map集合的方式

    （4）注意事项

    （5）Map的常用实现类

    4.Set

    （1）特点

    （2）常用方法

    （3）注意事项

    （4）Set的常用实现类

     5.哈希表

    （1）前言

     （2）哈希冲突

    （3）哈希函数

     直接定制法

    除留余数法

    冲突-避免-负载因子调节

     （4）冲突解决

    闭散列

    开散列（哈希桶）

     （5）模拟实现哈希桶

    1.二叉搜索树

    二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

    • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
    • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
    • 它的左右子树也分别为二叉搜索树
    1. public class BinarySearchTree {
    2.     static class TreeNode {
    3.         public int val;
    4.         TreeNode left;
    5.         TreeNode right;
    6.  
    7.         public TreeNode(int val) {
    8.             this.val = val;
    9.         }
    10.     }
    11.     public TreeNode root;
    12.  
    13.  
    14.     /**
    15.      * 判断二叉搜索树中是否存在值为key的节点
    16.      * @param key
    17.      */
    18.     public boolean search(int key) {
    19.         TreeNode cur = root;
    20.         if (cur == null) {
    21.             return false;
    22.         }
    23.  
    24.         while (cur != null) {
    25.             if (cur.val > key) {
    26.                 cur = cur.left;
    27.             } else if (cur.val < key) {
    28.                 cur = cur.right;
    29.             } else {
    30.                 return true;
    31.             }
    32.         }
    33.         return false;
    34.     }
    35.  
    36.  
    37.     /**
    38.      * 向二叉搜索树中插入元素
    39.      * @param val
    40.      */
    41.     public void insert(int val) {
    42.         TreeNode node = new TreeNode(val);
    43.         TreeNode cur = root;
    44.         TreeNode parent = root;
    45.         if (cur == null) {
    46.             root = node;
    47.             return;
    48.         }
    49.         while (cur != null) {
    50.             if (cur.val > val) {
    51.                 parent = cur;
    52.                 cur = cur.left;
    53.             } else if (cur.val < val) {
    54.                 parent = cur;
    55.                 cur = cur.right;
    56.             } else {
    57.                 //相同的节点不进行插入
    58.                 return;
    59.             }
    60.         }
    61.         //cur为null，判断是p的左还是右
    62.         if(parent.val > val) {
    63.             parent.left = node;
    64.         }else {
    65.             parent.right = node;
    66.         }
    67.     }
    68.  
    69.     /**
    70.      * 删除二叉搜索树的一个节点
    71.      * @param key
    72.      */
    73.     public void remove(int key) {
    74.         TreeNode cur = root;
    75.         TreeNode parent = root;
    76.         if (cur == null) {
    77.             return;
    78.         }
    79.         while (cur != null) {
    80.             if (cur.val > key) {
    81.                 parent = cur;
    82.                 cur = cur.left;
    83.             } else if (cur.val < key) {
    84.                 parent = cur;
    85.                 cur = cur.right;
    86.             } else {
    87.                 //开始删除节点
    88.                 removeNode(parent,cur);
    89.             }
    90.         }
    91.  
    92.     }
    93.  
    94.     private void removeNode(TreeNode parent,TreeNode cur) {
    95.         if (cur.left == null) {
    96.             if (cur == root) {
    97.                 root = cur.right;
    98.             } else if (cur == parent.left) {
    99.                 parent.left = cur.right;
    100.             } else {
    101.                 parent.right = cur.right;
    102.             }
    103.  
    104.         }else if (cur.right == null) {
    105.             if (cur == root) {
    106.                 root = cur.left;
    107.             }else if (cur == parent.left) {
    108.                 parent.left = cur.left;
    109.             } else {
    110.                 parent.right = cur.left;
    111.             }
    112.  
    113.         }else {
    114.             TreeNode t = cur.right;
    115.             TreeNode tp = cur;
    116.             while (t.left != null) {
    117.                 tp = t;
    118.                 t = tp.left;
    119.             }
    120.             //开始删除
    121.             cur.val = t.val;
    122.             if (t == tp.left) {
    123.                 tp.left = t.right;
    124.             } else {
    125.                 tp.right = t.right;
    126.             }
    127.         }
    128.     }
    129.  
    130. }

    2.搜索

    （1）概念及场景

    Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关

    静态类型的查找，即一般不会对区间进行插入和删除操作了：

    1. 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
    2. 二分查找，时间复杂度为 ,但搜索前必须要求序列是有序的

    动态查找，可能在查找时进行一些插入和删除的操作:

    1. Map和Set是 一种适合动态查找的集合容器。
       

    动态查找在现实中的适用场景：

    1. 根据姓名查询考试成绩
    2. 通讯录，即根据姓名查询联系方式
    3. 不重复集合，即需要先搜索关键字是否已经在集合中

    （2）模型

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

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

    Map中存储的就是key-value的键值对，Set中只存储了Key。

    3.Map

    （1）特点

    1. Map是一个双列集合，一个元素包含两个值（K,V）
    2. Map集合中的元素，key和value的数据类型可以相同，也可以不同
    3. Map是一个接口类，该类没有继承自Collection，该类中存储的是结构的键值对，并且K一定是唯一的，不能重复，V可以重复

     

    （2）常用方法

    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> entrySet()返回所有的 key-value 映射关系
    boolean containsKey(Object key)判断是否包含 key
    boolean containsValue(Object value)判断是否包含 value

    1. V put(K key, V value)：把指定的键和值添加到Map集合中，返回值是V

      如果要存储的键值对，key不重复返回值V是null

      如果要存储的键值对，key重复返回值V是被替换的value值 

      1. Map map = new TreeMap<>();
      2. String val1 = map.put("孙悟空","齐天大圣1");
      3. System.out.println(val1);
      4. String val2 = map.put("孙悟空","齐天大圣2");
      5. System.out.println(val2);
      6. System.out.println(map);
    2. V remove(Object key)：把指定键所对应的键值对元素，在Map集合中删除，返回被删除的元素的值。 

      如果key存在，返回被删除的值，如果key不存在，返回null 
      1. String ret1 = map.remove("孙悟空");
      2. System.out.println(ret1);
      3. String ret2 = map.remove("孙悟空1");
      4. System.out.println(ret2);

    3. V get(Object key)：根据指定的键 在Map集合中获取对应的值
       

      如果key存在，返回对应的value值，如果key不存在，返回null

      1. String val = map.get("孙悟空");
      2. System.out.println(val);
    4. boolean containsKey（ Object key）：判断集合中是否包含指定的键，包含true，不包含false
      boolean containsValue（ Object Value）：判断集合中是否包含指定的值，包含true，不包含false
        
      1. boolean val3 = map.containsKey("孙悟空");
      2. boolean val4 = map.containsValue("齐天大圣");
      3. System.out.println(val3);
      4. System.out.println(val4);

       

    （3）遍历Map集合的方式

    1. 通过键找值的方法
      使用了setKey方法，将Map集合中的key值，存储到Set集合，用迭代器或foreach循环遍历Set集合来获取Map集合的每一个key，并使用get（key）方法来获取value值 
      1. Map map = new TreeMap<>();
      2. map.put("孙悟空","齐天大圣");
      3. map.put("六小龄童","齐天大圣");
      4.  
      5.  
      6. Set set = map.keySet();
      7. System.out.println(set);
      8. Iterator it = set.iterator();
      9. while (it.hasNext()) {
      10.     String key = it.next();
      11.     String val = map.get(key);
      12.     System.out.println("key:" + key + " val:" + val);
      13. }

    2. 使用Entry对象遍历

      Map.Entry,在Map接口中有一个内部接口Entry（内部类）

      作用：当集合一创建，就会在Map集合中创建一个Entry对象，用来记录键与值（键值对对象，键值的映射关系）

      1. Set> entries = map.entrySet();
      2. for (Map.Entry entry: entries) {
      3.     //System.out.println("key:" + entry.getKey() + " val:" + entry.getValue());
      4.     entry.setValue("弼马温");
      5.     System.out.println("key:" + entry.getKey() + " val:" + entry.getValue());
      6. }

    （4）注意事项

    1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
    2. Map中存放键值对的Key是唯一的，value是可以重复的
    3. TreeMap中插入键值对时，key不能为空，否则就会抛NullPointerException异常，value可以为空。但是HashMap的key和value都可以为空。
    4. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。 
      1. public static void main(String[] args) {
      2.         //Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
      3.         Map map = new TreeMap<>();
      4.         map.put("孙悟空","齐天大圣");
      5.         map.put("六小龄童","齐天大圣");
      6.  
      7.  
      8.         Set set = map.keySet();
      9.         System.out.println(set);
      10.         Iterator it = set.iterator();
      11.         while (it.hasNext()) {
      12.             String key = it.next();
      13.             System.out.println("key:" + key);
      14.         }
      15.     }
    5. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行 重新插入。

    （5）Map的常用实现类

     TreeMap和HashMap的区别

    1. Map map1 = new TreeMap<>();
    2. Map map2 = new HashMap<>();

    4.Set

    （1）特点

    Set与Map主要的不同有两点：Set是继承自Collection的接口类，Set中只存储了Key。

    （2）常用方法

    （3）注意事项

    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可以。 

    （4）Set的常用实现类

     

    1. Set s1 = new TreeSet<>();
    2. Set s2 = new HashSet<>();

     5.哈希表

    （1）前言

    在我们之前学到的顺序结构和平衡树中，我们想查找一个元素必须经过关键码的多次比较才能找到，顺序结构的时间复杂度为O(N)，平衡树的时间复杂度为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的比较次数，这是因为元素的关键码与其存储的位置之间没有对应的关系；

    那么我么想达到一种理想的状态就是可以不通过任何比较，一次就可以找到要搜索的元素，如果构造一种存储结构，通过某种函 数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快 找到该元素。
     

    • 插入元素
      根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
    • 搜索元素
      对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若 关键码相等，则搜索成功

    该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)
     

     例如：数据集合{1，7，6，4，5，9}； 哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

     （2）哈希冲突

    不同关键字通过相同哈希数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

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

    （3）哈希函数

    引起哈希冲突的一个原因可能是：哈希函数设计不够合理。

     直接定制法

    取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B

    优点：简单、均匀

    缺点：需要事先知道关 键字的分布情况 使用场景：适合查找比较小且连续的情况

    除留余数法

    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数： Hash(key) = key% p(p<=m) 将关键码转换成哈希地址  

    冲突-避免-负载因子调节

    当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。

    已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

     （4）冲突解决

    解决哈希冲突两种常见的方法是：闭散列和开散列

    闭散列

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

    1. 线性探测
      线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

      采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他 元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标 记的伪删除法来删除一个元素。
    2. 二次探测
      线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨 着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：



      研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不 会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情 况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。

      因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

    开散列（哈希桶）

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

    数组+链表组成
    当数组长度>=64的时候并且链表长度>=8的时候这个链表就会变成红黑树


     （5）模拟实现哈希桶

    1. public class HashBuck {
    2.     static class Node {
    3.         public int key;
    4.         public int value;
    5.         public Node next;
    6.  
    7.         public Node(int key, int value) {
    8.             this.key = key;
    9.             this.value = value;
    10.         }
    11.     }
    12.     public Node[] array;
    13.     public int usedSize;
    14.     public double loadFactor = 0.75;//负载因子为0.75
    15.  
    16.     public HashBuck () {
    17.         array = new Node[10];
    18.     }
    19.  
    20.     public void put(int key,int value) {
    21.         int index = key % array.length;
    22.         Node cur = array[index]; //默认0,0,null
    23.         //1.遍历链表是否存在当前值  存在则更新
    24.         while (cur != null) {
    25.             if (cur.key == key) {
    26.                 cur.value = value;
    27.                 return;
    28.             }
    29.             cur = cur.next;
    30.         }
    31.  
    32.         //2.插入该节点  头插
    33.         Node node = new Node(key,value);
    34.         node.next = array[index];
    35.         array[index] = node;
    36.         usedSize++;
    37.  
    38.         //3.超出负载因子进行扩容
    39.         if (loadFacterCount() >= loadFactor) {
    40.             //扩容
    41.             resize();
    42.         }
    43.     }
    44.  
    45.     public Double loadFacterCount() {
    46.         return usedSize*1.0 /array.length;
    47.     }
    48.  
    49.     public void resize() {
    50.         //数组长度扩大为原数组的两倍
    51.         Node[] newArray = new Node[array.length*2];
    52.         //遍历链表
    53.         for (int i = 0; i < array.length; i++) {
    54.             Node cur = array[i];
    55.             while (cur != null) {
    56.                 int newIndex = cur.key % newArray.length;
    57.                 Node curN = cur.next;
    58.  
    59.                 cur.next = array[newIndex];
    60.                 newArray[newIndex] = cur;
    61.  
    62.                 cur = curN;
    63.             }
    64.         }
    65.  
    66.     }
    67.  
    68.  
    69.     public int get(int key) {
    70.         int index = key % array.length;
    71.         Node cur = array[index];
    72.         //1. 遍历当前链表 是否存在当前值
    73.         while (cur != null) {
    74.             if(cur.key == key) {
    75.                 return cur.value;
    76.             }
    77.             cur = cur.next;
    78.         }
    79.         return -1;
    80.     }
    81. }
    1. public class HashBuck2 {
    2.     static class Node {
    3.         public K key;
    4.         public V value;
    5.         public Node next;
    6.  
    7.         public Node(K key, V value) {
    8.             this.key = key;
    9.             this.value = value;
    10.         }
    11.     }
    12.  
    13.     public Node[] array = (Node[]) new Node[10];
    14.     public int usedSize;
    15.  
    16.     public void put(K key, V value) {
    17.         int hash = key.hashCode();
    18.         int index = hash % array.length;
    19.         Node cur = array[index];
    20.         //1.检查是否相同，相同更新
    21.         while (cur != null) {
    22.             if (cur.key.equals(key)) {
    23.                 cur.value = value;
    24.                 return;
    25.             }
    26.             cur = cur.next;
    27.         }
    28.         //2.不相同则头插
    29.         Node node = new Node(key, value);
    30.         node.next = array[index];
    31.         array[index] = node;
    32.         usedSize++;
    33.     }
    34.  
    35.  
    36.     public V get(K key) {
    37.         int hash = key.hashCode();
    38.         int index = hash % array.length;
    39.         Node cur = array[index];
    40.         //1. 遍历当前链表 是否存在当前值
    41.         while (cur != null) {
    42.             if (cur.key.equals(key)) {
    43.                 return cur.value;
    44.             }
    45.             cur = cur.next;
    46.         }
    47.         return null;
    48.     }
    49. }

  • 相关阅读:
    Java: Java中接口和抽象类的区别以及应用场景
    k线图形态这样记（口诀篇）
    回顾多线程
    AS Level和A2 Level的区别及难度
    记录单片机编码的坑
    跨境电商独立站如何建立呢？
    AI大模型安装
    【算法自由之路】重要的堆结构、堆排序排序算法通用比较器
    正则表达式
    Java Number包含哪几种类型呢？
  • 原文地址：https://blog.csdn.net/weixin_61196535/article/details/140438413