Java set时间复杂度 java map 时间复杂度

目录

引入：

模型：

Map的使用：

常见方法：

Set的使用：

常见方法：

搜索树

概念：

 操作：

查找：

 插入：

 删除：

哈希表

概念：

冲突

哈希函数设计

负载因子的调节

解决哈希冲突

闭散列

开散列

---

引入：

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

以前常见的搜索方式有：

1. 直接遍历，时间复杂度为 O(N) ，元素如果比较多效率会非常慢

2. 二分查找，时间复杂度为 O(logN),但搜索前必须要求序列是有序的

本节介绍的Map和Set是 一种适合动态查找的集合容器。

模型：

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

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

Map的使用：

Map 是一个接口类，该类没有继承自 Collection ，该类中存储的是 <K,V> 结构的键值对，并且 K 一定是唯一的，不 能重复 。

常见方法：

V get(Object key)

V getOrDefault(Object key, V defaultValue)------返回key对应的value如果不存在返回默认值

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. 在 Map 中插入键值对时， key 不能为空，否则就会抛 NullPointerException 异常 ，但是 value 可以为空

4. Map 中的 Key 可以全部分离出来，存储到 Set 中 来进行访问 ( 因为 Key 不能重复 ) 。

5. Map 中的 value 可以全部分离出来，存储在 Collection 的任何一个子集合中 (value 可能有重复 ) 。

6. Map 中键值对的 Key 不能直接修改， value 可以修改，如果要修改 key ，只能先将该 key 删除掉，然后再来进行重新插入。

Set的使用：

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

常见方法：

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是否为空

Object[] toArray() ------将set中的元素转换为数组返回

boolean containsAll(Collection<?> c)------集合c 中的元素是否在 set 中全部存在

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 。

搜索树

概念：

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

• 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
• 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
• 它的左右子树也分别为二叉搜索树

 操作：

查找：

如果根结点不为空

如果根节点key=查找key，返回true

如果根节点key<查找key，在左树查找

如果根节点key>查找key，在右树查找

否则返回false

图解：

代码：

public Node search(int key) {
    Node cur = root;
    while (cur != null) {
        if (key == cur.key) {
            return cur;
        } 
        else if (key < cur.key) {
            cur = cur.left;
        }
        else {
            cur = cur.right;
        }
    } 
    return null;
}

 插入：

1. 如果树为空树，即根 == null，直接插入

2. 如果树不是空树，按照查找逻辑确定插入位置，插入新结点

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

 删除：

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

若 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

若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

若cur.left != null && cur.right != null
1. 需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题

哈希表

概念：

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

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

例如：

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

 但是当我们存入24的时候，就会发生冲突。

冲突

对于不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率。

哈希函数设计

直接定制法--(常用)

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况。

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

平方取中法--(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况。

折叠法--(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况。

负载因子的调节

冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

负载因子 =填入表中的元素个数/散列表的长度

解决哈希冲突

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

闭散列

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

开散列

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