数据结构之Map和Set总结

C++的STL 中 set.map multiset.multimap 学习使用详细讲解(含配套OJ题练习使用详细解答) 阅读详情

目录

一、概念与模型

二、Map的使用

三、Set的说明

1.一些常用的方法

四、一些小练习

五、搜索树

1.概念

2.查找操作

3.插入操作

4.删除操作

六、哈希表

1.概念

2.冲突


一、概念与模型

1.概念:Map 和 set 是一种专门用来进行搜索的容器或者数据结构,其搜索的效率与其具体的实例化子类有关 。以前常见的搜索方式有: ①直接遍历,时间复杂度为O(N) ,元素如果比较多效率会非常慢 ②二分查找,时间复杂度为O(logN),但搜索前必须要求序列是有序的 。上述排序比较适合静态类型的查找,即一般不会对区间进行插入和删除操作了,而现实中的查找比如: ①根据姓名查询考试成绩 ②通讯录,即根据姓名查询联系方式 ③不重复集合,即需要先搜索关键字是否已经在集合中,可能在查找时进行一些插入和删除的操作,即动态查找,那上述两种方式就不太适合了,本博客总结的Map 和 Set 是一种适合动态查找的集合容器。
2.模型:
一般把搜索的数据称为关键字( Key ),和关键字对应的称为值( Value ),将其称之为 Key-value 的键值对,所以模型会有两种:
(1)纯 key 模型 ,如: 有一个英文词典,快速查找一个单词是否在词典中快速查找某个名字在不在通讯录中
(2)Key-Value 模型 ,如: ①统计文件中每个单词出现的次数,统计结果是每个单词都有与其对应的次数:< 单词,单词出现的次数 > ②梁山好汉的江湖绰号:每个好汉都有自己的江湖绰号。
而Map 中存储的就是 key-value 的键值对, Set 中只存储了 Key 。

二、Map的使用

1.Map 是一个接口类,该类没有继承自 Collection ,该类中存储的是 <K,V> 结构的键值对,并且 K 一定是唯一的,不 能重复 。
2. 关于 Map.Entry<K, V> 的说明
方法
解释
K getKey()
返回 entry 中的 key
V getValue()
返回 entry 中的 value
V setValue(V value)
将键值对中的 value 替换为指定 value

3.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<K> keySet()
返回所有 key 的不重复集合
Collection<V> values()
返回所有 value 的可重复集合
Set<Map.Entry<K, V>> entrySet()
返回所有的 key-value 映射关系
boolean containsKey(Object key)
判断是否包含 key
boolean containsValue(Object value)
判断是否包含 value
(1)Map 是一个接口,不能直接实例化对象 ,如果 要实例化对象只能实例化其实现类 TreeMap 或者 HashMap
(2)Map 中存放键值对的 Key 是唯一的, value 是可以重复的
(3)在TreeMap中插入键值对时,key 不能为空,否则就会抛 NullPointerException 异常 ,但是 value 可以为空,但是HashMap两个都可以为空
(4)Map 中的 Key 可以全部分离出来,存储到 Set 中 来进行访问 ( 因为 Key 不能重复 ) 。
(5)Map 中的 value 可以全部分离出来,存储在 Collection 的任何一个子集合中 (value 可能有重复 ) 。
(6)Map 中键值对的 Key 不能直接修改, value 可以修改,如果要修改 key ,只能先将该 key 删除掉,然后再来进行重新插入。
TreeMap 和 HashMap 的区别:
Map 底层结构
TreeMap
HashMap
底层结构
红黑树
哈希桶
插入 / 删除 / 查找时间复杂度
O(logN)
O(1)
是否有序
关于 Key 有序
无序
线程安全
不安全
不安全
插入 / 删除 / 查找区别
需要进行元素比较
通过哈希函数计算哈希地址
比较与覆写
key 必须能够比较,否则会抛出ClassCastException异常
自定义类型需要覆写 equals 和hashCode方法
应用场景
需要 Key 有序场景下
Key 是否有序不关心,需要更高的时间性能

三、Set的说明

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

1.一些常用的方法

方法
解释
boolean add(E e)
添加元素,但重复元素不会被添加成功
void clear()
清空集合
boolean contains(Object o)
判断 o 是否在集合中
Iterator<E> 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)Set 的底层是使用 Map 来实现的,其使用 key 与 Object 的一个默认对象作为键值对插入到 Map 中的
(4)Set 最大的功能就是对集合中的元素进行去重
(5)实现 Set 接口的常用类有 TreeSet 和 HashSet ,还有一个 LinkedHashSet , LinkedHashSet 是在 HashSet 的基础上维护了一个双向链表来记录元素的插入次序。
(6)Set 中的 Key 不能修改,如果要修改,先将原来的删除掉,然后再重新插入
(7)Set 中不能插入 null 的 key 。
(8)TreeSet 和 HashSet 的区别:
Set 底层结构
TreeSet
HashSet
底层结构
红黑树
哈希桶
插入 / 删除 / 查找时间复杂度
O(logN)
O(1)
是否有序
关于 Key 有序
不一定有序
线程安全
不安全
不安全
插入 / 删除 / 查找区别
按照红黑树的特性来进行插入和删除
①先计算 key 哈希地址② 然后进行插入和删除
比较与覆写
key 必须能够比较,否则会抛出ClassCastException异常
自定义类型需要覆写 equals 和hashCode方法
应用场景
需要 Key 有序场景下
Key 是否有序不关心,需要更高的时间性能

四、一些小练习

1.给定10W个数据,统计每个数据出现的次数

public class TestDemo {
    public static Map<Integer,Integer> func(int[] arr){
        Map<Integer,Integer> map = new HashMap<>();
        for (int x:arr) {
            if(map.get(x) == null){
                map.put(x,1);
            }else{
                int val = map.get(x);
                map.put(x,val+1);
            }
        }
        return map;
    }
    public static void main(String[] args) {
        int[] arr = new int[10_0000];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(1000);
        }
        Map<Integer,Integer> map = func(arr);
        System.out.println(map);
    }
}

2.将10W个数据中的数据去重

把数据放到Set即可

public static Set<Integer> func2(int[] arr){
    HashSet<Integer> set = new HashSet<>();
    for (int x:arr) {
        set.add(x);
    }
    return set;
}

3.从10W个数据中找到第一个重复的数据

把数据放到Set中,放之前检查一下,Set中是不是已经有了
public static int func3(int[] arr){
    HashSet<Integer> set = new HashSet<>();
    for (int x:arr) {
        if(set.contains(x)){
             return x;
        }
        set.add(x);
   }
        return -1;
}

五、搜索树

1.概念

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

2.查找操作

class Node{
    public int val;
    public Node left;
    public Node right;

    public Node(int val){
        this.val = val;
    }
}
public class BinarySearchTree {
    Node root = null;

    public Node search(int key){
        Node cur = root;
        while(cur != null){
            if(cur.val < key){
                cur = cur.right;
            }else if(cur.val > key){
                cur = cur.left;
            }else{
                return cur;
            }
        }
        return null;//没有这个数据
    }
}

3.插入操作

class Node{
    public int val;
    public Node left;
    public Node right;

    public Node(int val){
        this.val = val;
    }
}
public class BinarySearchTree {
    Node root = null;

    public boolean insert(int val){
        if(root == null){
            root = new Node(val);
            return true;
        }
        Node cur = root;
        Node parent = null;
        while(cur != null){
            if(cur.val < val){
                parent = cur;
                cur = cur.right;
            }else if(cur.val == val){
                return false;//不能有相同数据进行插入
            }else{
                parent = cur;
                cur = cur.left;
            }
        }
        Node node = new Node(val);
        if(parent.val < val){
            parent.right = node;
        }else{
            parent.left = node;
        }
        return true;
    }
    
}

4.删除操作

设待删除结点为 cur, 待删除结点的双亲结点为 parent
(1)情况一: cur.left == null
①cur 是 root ,则 root = cur.right
②cur 不是 root , cur 是 parent.left ,则 parent.left = cur.right
③cur 不是 root , cur 是 parent.right ,则 parent.right = cur.right
(2)情况二: cur.right == null
①cur 是 root ,则 root = cur.left
②cur 不是 root , cur 是 parent.left ,则 parent.left = cur.left
③cur 不是 root , cur 是 parent.right ,则 parent.right = cur.left
(3)情况三:cur.left != null && cur.right != null
class Node{
    public int val;
    public Node left;
    public Node right;

    public Node(int val){
        this.val = val;
    }
}
public class BinarySearchTree {
    Node root = null;

    public void remove(int key){
        Node cur = root;
        Node parent = null;
        while(cur != null){
            if(cur.val == key){
                removeNode(cur,parent);
                break;
            }else if(cur.val < key){
                parent = cur;
                cur = cur.right;
            }else{
                parent = cur;
                cur = cur.left;
            }
        }
    }
    public void removeNode(Node cur,Node parent){
        if(cur.left == null){
            if(cur == root){
                root = cur.right;
            }else if(cur == parent.left){
                parent.left = cur.right;
            }else{
                parent.right = cur.right;
            }
        }else if(cur.right == null){
            if(cur == root){
                root = cur.left;
            }else if(cur == parent.left){
                parent.left = cur.left;
            }else{
                parent.right = cur.left;
            }
        }else{
            Node targetParent = cur;
            Node target = cur.right;
            while(target.left != null){
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            if(target == targetParent.left){
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }
    public void inOrder(Node root){
        if(root == null){
            return;
        }
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }
}
插入和删除操作都必须先查找,查找效率代表了二叉搜索树中各个操作的性能。 对有n 个结点的二叉搜索树,若每个元素查找的概率相等,则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数,即结点越深,则比较次数越多
最优情况下,二叉搜索树为完全二叉树,其时间复杂度为O(logn)
最差情况下,二叉搜索树退化为单支树,其时间复杂度为O(n)
TreeMap 和 TreeSet 即 java 中利用搜索树实现的 Map 和 Set ;实际上用的是红黑树,而红黑树是一棵近似平衡的二叉搜索树,即在二叉搜索树的基础之上 + 颜色以及红黑树性质验证,关于红黑树的知识点我们后面再总结

六、哈希表

1.概念

顺序结构以及平衡树 中,元素关键码与其存储位置之间没有对应的关系,因此在 查找一个元素时,必须要经过关键 码的多次比较 。 顺序查找时间复杂度为 O(N) ,平衡树中为树的高度,即 O(logn ),搜索的效率取决于搜索过程中元素的比较次数。 理想的搜索方法:可以 不经过任何比较,一次直接从表中得到要搜索的元素。 如果构造一种存储结构,通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系,那么在查找时通过该函数可以很快找到该元素。
当向该结构中:
插入元素
根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素
对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若
关键码相等,则搜索成功
该方式即为哈希 ( 散列 ) 方法, 哈希方法中使用的转换函数称为哈希 ( 散列 ) 函数,构造出来的结构称为哈希表 (Hash Table)( 或者称散列表 )

2.冲突

(1)概念:对于两个数据元素的关键字 和 (i != j) ,有 != ,但有: Hash( ) == Hash( ) ,即: 不同关键字通过相同哈 希函数计算出相同的哈希地址,该种现象称为哈希冲突或哈希碰撞 。 把具有不同关键码而具有相同哈希地址的数据元素称为 “ 同义词 ” 。
注意: 由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的,这就导致一 个问题, 冲突的发生是必然的 ,但我们能做的应该是尽量的 降低冲突率
(2)冲突-->避免
引起哈希冲突的其中一个原因可能是: 哈希函数设计不够合理 。 哈希函数设计原则 :

①哈希函数的定义域必须包括需要存储的全部关键码,而如果散列表允许有m个地址时,其值域必须在0到m-1之间

②哈希函数计算出来的地址能均匀分布在整个空间中

③哈希函数应该比较简单

常见的哈希函数:

①直接定制法(常用):取关键字的某个线性函数为散列地址:Hash(Key)= A*Key + B 优点:简单、均匀 缺点:需要事先知道关键字的分布情况 使用场景:适合查找比较小且连续的情况

我们来看一条题:

 代码实现:

class Solution {
    public int firstUniqChar(String s) {
        if(s == null){
            return -1;
        }
        int[] arr = new int[26];
        for(int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            arr[ch-97]++;
        }
        for(int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            if(arr[ch-97] == 1){
                return i;
            }
        }
        return -1;
    }
}
② 除留余数法 (常用) :
设散列表中允许的 地址数为 m ,取一个不大于 m ,但最接近或者等于 m 的质数 p 作为除数,按照哈希函数: Hash(key) = key% p(p<=m), 将关键码转换成哈希地址
③平方取中法: 假设关键字为 1234 ,对它平方就是 1522756 ,抽取中间的 3 位 227 作为哈希地址; 再比如关键字为 4321 ,对它平方就是18671041 ,抽取中间的 3 位 671( 或 710) 作为哈希地址 平方取中法比较适合:不知道关键字的分 布,而位数又不是很大的情况
④折叠法:
将关键字从左到右分割成位数相等的几部分 ( 最后一部分位数可以短些 ) ,然后将这几部分叠加求和,并按散列表表长,取后几位作为散列地址。
折叠法适合事先不需要知道关键字的分布,适合关键字位数比较多的情况
⑤随机数法:选择一个随机函数,取关键字的随机函数值为它的哈希地址,即H(key) = random(key), 其中 random 为随机数函数。
通常应用于关键字长度不等时采用此法
⑥数学分析法:
设有 n 个 d 位数,每一位可能有 r 种不同的符号,这 r种不同的符号在各位上出现的频率不一定相同,可能在某些位上分布比较均匀,每种符号出现的机会均等,在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小,选择其中各种符号分布均匀的若干位作为散列地址。如: 假设要存储某家公司员工登记表,如果用手机号作为关键字,那么极有可能前 7 位都是 相同的,那么我们可以
选择后面的四位作为散列地址,如果这样的抽取工作还容易出现 冲突,还可以对抽取出来的数字进行反转 ( 如1234改成 4321) 、右环位移 ( 如 1234 改成 4123) 、左环移位、前两数与后两数叠加 ( 如 1234 改成 12+34=46) 等方法。 数字分析法通常适合处理关键字位数比较大的情况,如果事先知道关键字的分布且关键字的若干位分布较均 匀的情况
注意:哈希函数设计的越精妙,产生哈希冲突的可能性就越低,但是无法避免哈希冲突
降低冲突率的另一个方法: 负载因子调节
负载因子α=存储散列表的元素个数/散列表的长度
α是散列表装满程度的标志因子。由于表长是定值,α与“填入表中元素的个数”成正比,所以α越大,表明填入表中的元素越多,产生冲突的可能性越大;反之,α越小,表明填入表中的元素越少,产生冲突的可能性越少。实际上,散列表的平均查找长度是α的函数,只是不同处理冲突的方法有不同的函数。对于开放定址法,α是特别重要的因素,应严格限制在0.7~0.8以下,超过0.8,查表时的CPU缓存不命中按照指数曲线上升。因此,一些采用开放定址法的hash库,如Java的系统限制了α为0.75,超过此值将resize散列表
α与冲突率的关系图:
所以当冲突率达到一个无法忍受的程度时,我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的,那我们能调整的就只有哈希表中的数组的大小。
(3)冲突-->解决
解决哈希冲突 两种常见的方法是: 闭散列 和 开散列
(i)闭散列
也叫开放地址法,当发生哈希冲突时,如果哈希表未被装满,说明在哈希表中必然还有空位置,那么可以 把 key 存放到冲突位置中的 “ 下一个 ” 空位置中去。
如何寻找下一个空位置?
① 线性探测:从发生冲突的位置开始,依次向后探测,直到寻找到下一个空位置为止。插入:
  • 通过哈希函数获取待插入元素在哈希表中的位置
  • 如果该位置中没有元素则直接插入新元素,如果该位置中有元素发生哈希冲突,使用线性探测找到下一个空位置,插入新元素
  • 采用闭散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素,若直接删除元素会影响其他元素的搜索。比如删除元素4; 如果直接删除掉, 44 查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
  • 线性探测的缺陷是产生冲突的数据堆积在一块,这与其找下一个空位置有关系,因为找空位置的方式就是挨着往后逐个去找

②二次探测:
二次探测为了避免线性探测的问题,找下一个空位置的方法为:Hi= (H0+i^2)% m, 或者:Hi= (H0+i^2)% m。其中:i = 1,2,3…,H0是通过散列函数Hash(x) 对元素的关键码 key 进行计算得到的位置,m是表的大小。 对于上面 中如果要插入 44 ,产生冲突,使用解决后的情况为

 研究表明:当表的长度为质数且表装载因子a不超过0.5时,新的表项一定能够插入,而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置,就不会存在表满的问题。在搜索时可以不考虑表装满的情况,但在插入时必须确保表的装载因子a不超过0.5,如果超出必须考虑增容。 因此:比散列最大的缺陷就是空间利用率比较低,这也是哈希的缺陷

(ii)开散列

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

 代码实现:

public class HashBuck {
    static class Node{
        public int key;
        public int val;
        public Node next;

        public Node(int key, int val){
            this.key = key;
            this.val = val;
        }
    }
    public Node[] arr;
    public int usedSize;
    public static final double DEFAULT_LOADFactor = 0.75;

    public HashBuck(){
        this.arr = new Node[10];
    }

    public void put(int key, int val){
        //找到key所在的位置
        int index = key % this.arr.length;
        //遍历下标的链表,看看是不是有相同的key,如果有,要更新val
        Node cur = arr[index];
        while(cur != null){
            if(cur.key == key){
                cur.val = val;
                return;
            }
            cur = cur.next;
        }
        //没有key这个元素,头插法插入
        Node node = new Node(key,val);
        node.next = arr[index];
        arr[index] = node;
        this.usedSize++;
        //插入元素成功后,检查当前散列表的负载因子
        if(loadFactor() > DEFAULT_LOADFactor){
            resize();//扩容----->不是简单的把数组扩大,数组里面的每个链表的每个元素必须重新进行哈希
                     //14%10=4   14%20=14
        }
    }

    private void resize(){
        Node[] newArr = new Node[arr.length*2];
        for(int i = 0; i < this.arr.length; i++){
            Node cur = arr[i];
            while(cur != null){
                int index = cur.key % newArr.length;//获取新的下标
                //把cur这个节点,以头插或者尾插的方式插入到新的数组对应下标的链表当中
                Node curNext = cur.next;
                cur.next = newArr[index];//先绑定前面
                newArr[index] = cur;//再绑定后面
                cur = curNext;
            }
        }
        arr = newArr;
    }

    private double loadFactor(){
        return 1.0 * usedSize / this.arr.length;
    }

    public int get(int key){
        //找到key所在的位置
        int index = key % this.arr.length;
        //遍历下标的链表,看看是不是有相同的key,如果有,要更新val
        Node cur = arr[index];
        while(cur != null){
            if(cur.key == key){
                return cur.key;
            }
            cur = cur.next;
        }
        return -1;
    }
}
进阶代码实现:
import java.util.HashMap;
import java.util.Objects;

class Person{
    public String ID;

    public Person(String ID){
        this.ID = ID;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(ID, person.ID);
    }

    @Override
    public int hashCode() {
        return Objects.hash(ID);
    }

    @Override
    public String toString() {
        return "Person{" +
                "ID='" + ID + '\'' +
                '}';
    }
}
public class HashBuck2<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>[] arr = (Node<K,V>[])new Node[10];
    public int usedSize;

    public void put(K key, V val){
        int hash = key.hashCode();//hashcode()寻找位置
        int index = hash % arr.length;
        Node<K,V> cur = arr[index];
        while(cur != null){
            if(cur.key.equals(key)){//equals()负责查看有没有一样的元素
                cur.val = val;
                return;
            }
            cur = cur.next;
        }
        Node<K,V> node = new Node(key,val);
        node.next = arr[index];
        arr[index] = node;
        this.usedSize++;
    }
    //hashcode()一样,equals()不一定一样;equals()一样,hashcode()一定一样

    public V get(K key){
        int hash = key.hashCode();//hashcode()寻找位置
        int index = hash % arr.length;
        Node<K,V> cur = arr[index];
        while(cur != null){
            if(cur.key.equals(key)){//equals()负责查看有没有一样的元素
                return cur.val;
            }
            cur = cur.next;
        }
        return null;
    }

    public static void main(String[] args) {
        Person person1 = new Person("123");
        Person person2 = new Person("123");

        HashBuck2<Person,String> hashBuck2 = new HashBuck2();
        hashBuck2.put(person1,"abc");

        System.out.println(hashBuck2.get(person2));

    }
}

编译运行该代码,输出如下:

abc

(3)一些问题:
①如果new HashMap(19),bucket数组多大?
②HashMap什么时候开辟bucket数组占用内存的?
③HashMap何时扩容?

 

 



(4)一个小题

 求下面的查找成功的平均长度以及查找不成功的平均长度:

 

Map和Set的常用方法和简述 是一组键值对的结构,用于解决以往不能用对象做为键的问题,具有极快的查找速度。5. map和set都是stl中的关联容器,map以键值对的形式存储,key=value组成pair,是一组映射关。Set和Map类似,也是一组key的集合,但不存储value。4. Set的值是唯一的可以做数组去重,Map由于没有格式限制,可以做数据存储。set只有值,可以认为只有一个数据,并且set中元素不可以重复且自动排序。1. Map是键值对,Set是值的集合,当然键和值可以是任何的值;... 阅读详情

相关推荐

Java集合与数据结构 Map 和 Set

Java集合与数据结构 Map和Set搜索树操作:查找、插入、删除 搜索树 二叉搜索树又称二叉排序树,它或者是一棵空树**,或者是具有以下性质的二叉树: 若它的左子树不为空,则左子树上所有节点的值都小于根节点的值 若它的右子树不为空,则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 操作:查找、插入、删除 逻辑代码: class BinarySearchTree { static class BSNode { public int val;

Kaiii的博客 525

Map和Set

前言 一、pandas是什么? 二、使用步骤 总结

qq_774952435的博客 3929

set 和map 的区别是什么?

需要根据具体的需求和数据结构特点来选择使用 Set 还是 Map。如果只需要存储唯一值并且不关心顺序,使用 Set;如果需要将值与键关联,并且需要根据键进行查找和操作,使用 Map。

祈澈菇凉 4444

【数据结构】Map和Set

本期主要讲解: 1、Map 和 Set的概念 2、Map 和 Set 使用的模型 3、Map 3.1 Map.Entry 简介 3.2 Map的常用方法 4、Set 4.1 Set 和 Map 的区别 4.2 Set 的常用方法

拼命阿紫冲冲冲! 2196

材料力学小白必看:纯弯曲正应力计算全解析(附实例演示)

本文详细解析了材料力学中纯弯曲正应力的计算原理与工程应用,通过实例演示帮助初学者掌握关键公式和计算流程。内容涵盖纯弯曲的基本假设、正应力分布规律、截面特性计算,以及现代工具如Excel、ANSYS和Python在应力分析中的应用,特别适合材料力学小白系统学习。

sea99的博客 1234

PCIE配置和地址空间

来源:https://www.jianshu.com/p/574e9a2cbc4e 每个PCIe设备,有这么一段空间,Host软件可以读取它获得该设备的一些信息,也可以通过它来配置该设备,这段空间就叫做PCIe的配置空间。不同于每个设备的其它空间,PCIe设备的配置空间是协议规定好的,哪个地方放什么内容,都是有定义的。PCI或者PCI-X时代就有配置空间的概念,那时的配置空间如下: 图6.1 整个配置空间就是一系列寄存器的集合,其中Type 0是Endpoint的配置,Type 1是Brid.

qq_28643619的博客 4064

[数据结构]-map和set

本期学习目标:理解什么是键值对,实现红黑树的迭代器,模拟实现map和set.

分享技术 4604

AGV路径规划实战:如何用Python+ROS实现激光SLAM导航(附避障代码)

本文提供了一份基于Python和ROS实现AGV激光SLAM导航的实战指南。内容涵盖从Docker环境搭建、激光雷达数据处理、Gmapping建图,到Move_Base全局/局部路径规划与TEB局部规划器配置的全流程。重点解析了如何通过参数调优实现稳定导航,并附带了紧急避障代码,帮助开发者快速构建具备自主路径规划与实时避障能力的AGV系统。

pepsi的博客 1238

【数据结构】 map 和 set

数据结构中Map和Set的学习~

qq_56251766的博客 717

动态数据脱敏技术分析

在当前国内信息安全热潮中,数据脱敏作为数据安全的重要一环得到了业界的认可与重视。早在2012年,数据脱敏首次作为一个单独的魔力象限由Gartner发布,Gartner在2014年又提出了:按照数据使用场景,将数据脱敏分为静态数据脱敏(Static data masking-SDM )与动态数据脱敏(Dynamic data masking-DDM )。 可能有人望文生义,认为动态数据脱敏一定比静态数据脱敏高级。非也非也,静态or动态,取决于脱敏的使用场景,主要是以使用场景为由来选择合适的数据脱敏的模式。 本

美创科技的博客 4680

正交试验实战指南:从PICT工具到混合水平表应用

本文详细介绍了正交试验法在测试设计中的实战应用,从基础概念到PICT工具的高级使用技巧。通过混合水平表设计和工程化实践案例,帮助测试工程师高效解决参数组合爆炸问题,提升测试覆盖率与效率。特别适合兼容性测试和复杂系统验证场景。

weixin_29230865的博客 261

Set和Map数据结构

Set它类似与数组,数组中的成员都是唯一的,没有重复的。

angel_wty的博客 990

基于 ESP32 的智能药盒提醒装置设计与实现

本装置基于 ESP32 实现了智能药盒的核心功能,硬件选型兼顾成本与实用性,软件设计模块化、易拓展。后续可通过 ESP32 的 WiFi 模块接入物联网平台(如阿里云、OneNet),实现远程设置提醒、服药状态反馈等功能,进一步提升智能化水平。该装置能有效解决老人忘服药问题,具有较高的实用价值与推广潜力。

weixin_42300449的博客 1046

数据结构之详解【Map和Set】

1.Map是一个接口,不能直接实例化对象(要实例化对象可以实现类TreeMap或HashMap) 2.Map中存放键值对的key是唯一的,value是可以重复一样的 3.Map中key可以全部分离开,存储在Set中去进行访问(因为key不可以重复) 4.Map中value可以全部分离开,存储在Collection的任何一个子集合中(value可以重复) 5.Map中key不能直接修改,如果必须修改就要先删除key,在进行重新插入 6.HashMap的存储 是根据底层的哈希函数和key,去找对应的位...

m0_58761900的博客 2308

改进YOLOv9的CT图像肺结节检测与分类算法:从原理到实战

本文将详细介绍如何改进YOLOv9算法,使其更好地适应CT图像肺结节检测与分类任务。我们将从数据集准备、模型改进、训练优化到最终部署,完整呈现一个端到端的深度学习项目,并提供完整的代码实现。

YOLO 191

数据架构师必看:大数据时代的架构演进与实践

数据架构是企业数据资产的“骨架”——它决定了数据能多快被处理、多准被分析、多安全被存储。本文将聚焦从传统架构到大数据架构的关键转折点,覆盖技术选型、典型场景、落地挑战三大核心命题,帮助读者建立“演进思维”而非“固定思维”。本文将按“历史演进→核心概念→技术原理→实战案例→趋势展望”的逻辑展开,用“超市仓库升级”贯穿始终,让抽象的技术概念具象化。传统数据仓库:精但小,适合结构化、批量分析。大数据架构:大但乱,适合全类型、海量数据存储。流批一体:解决实时+批量的效率问题。湖仓一体。

AI Agent Harness Engineering 915

【JavaScript】Set和Map数据结构

💡 Map数据结构是一个类似于对象的数据结构,它的key可以是任何数据类型, 可以被看做为一个 值 = 值 的数据结构。💡 Set数据结构是ES6新增的数据结构,是一个类似于数组的数据结构,按照索引排列。var s = new Set([数据1, 数据2, 数据3…利用Set不接受重复数据的特点封装函数给数组去重。

LuWeien的博客 1846

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

【数据结构】之 Map和Set

通过上面这张图我们可以看出,Map的两个实例化类分别是HashMap和TreeMap。HashMap和TreeMap的区别:在Java中HashMap的底层是实现了一个哈希桶,本文的后面会详细介绍;而TreeMap的底层是红黑树,而红黑树是一棵近似平衡的二叉搜索树,即在二叉搜索树的基础之上 +颜色以及红黑树性质验证,关于红黑树的性质我们之后再做详解。这里我们对二叉搜索树有大致理解即可,可以翻看我之前的二叉搜索树章节进行理解。代码实现:(这里只介绍几种)

weixin_62848751的博客 1385

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

ES6数据结构Set和Map的区别

Set和Map的区别 1. Map保存键值对,任何值都可以作为键值的值。 2. Set保存的是类数组数据,是值的集合。

前端啤酒屋 7128

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Java数据结构 Map和Set详解

6. Map中键值对的Key不能直接修改,value可以修改,如果要修改key,只能先将该key删除掉,然后再来进行 重新插入。搜索元素 对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若 关键码相等,则搜索成功。Map是一个接口类,该类没有继承自Collection,该类中存储的是结构的键值对,并且K一定是唯一的,不 能重复。3. TreeSet的底层是使用Map来实现的,其使用key与Object的一个默认对象作为键值对插入到Map中的。

2301_79482961的博客 1053

数据结构——Map 和 Set

Map和Set是两种用于搜索的数据结构。Map是Key-Value模型存储键值对,Key唯一而Value可重复;Set是纯Key模型。两者的区别主要是什么?

2301_76937176的博客 1118

数据结构:Map和Set

int key;int value;Node next;

2403_87667675的博客 875
上一篇: 数据结构之泛型总结
下一篇: 反射枚举及lambda的使用
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值