数据结构（Map、Set）

一、搜索树

1.1 概念

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

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

1.2 操作

查找

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

• 时间复杂度： O(logn) 【好的情况】，如果出现单分支，则可能是O(n)

插入

public boolean insert(int key) {
    TreeNode node = new TreeNode(key);
    
    //第一次插入的时候
    if(root == null) {
        root = node;
        return true;
    }
    TreeNode cur = root;
    TreeNode parent = null;
    
    while (cur != null) {
        if(cur.val < key) {
            parent = cur;
            cur = cur.right;
        }else if(cur.val == key) {
            return false;//一样的值 不能进行插入
        }else {
            parent = cur;
            cur = cur.left;
        }
    }
    
    if(parent.val > key) {
        parent.left = node;
    }else {
        parent.right = node;
    }
    return true;
}

删除

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

• 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
• 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
• cur.left != null && cur.right != null
  • 需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，或者是找左子树中的最大值，用它的值填补到被删除节点中，再来处理该结点的删除问题

 public void removeNode(int key) {
     TreeNode cur = root;
     TreeNode parent = null;
     while (cur != null) {
         if(cur.val < key) {
             parent = cur;
             cur = cur.right;
         }else if(cur.val > key) {
             parent = cur;
             cur = cur.left;
         }else {
             remove(cur,parent);
             return;
         }
     }
 }

 private void remove(TreeNode cur, TreeNode 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(parent.left == cur) {
             parent.left = cur.left;
         }else {
             parent.right = cur.left;
         }
     }else {
         //cur的左右两边 都不为空 ！！
         TreeNode targetParent = cur;
         TreeNode 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;
         }
     }
 }

1.3 与java类集的关系

TreeMap 和 TreeSet 即 java 中利用二叉搜索树实现的 Map 和 Set

实际上用的是红黑树，而红黑树是一棵近似平衡的二叉搜索树

二、Map 和 Set

2.1 概述

概念和场景

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

直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
二分查找，时间复杂度为O(logN) ,但搜索前必须要求序列是有序的
直接查找和二分查找都比较适合静态类型的查找

Map和Set是一种适合动态查找(可能在查找时进行一些插入和删除的操作)的集合容器

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

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

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

2.2 Map

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

1. 关于Map.Entry的说明
Map.Entry 是Map内部实现的用来存放键值对映射关系的内部类

方法	解释
K getKey()	返回 entry 中的 key
V getValue()	返回 entry 中的 value
V setValue(V value)	将键值对中的value替换为指定value

1. Map 的常用方法说明

1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
2. Map中存放键值对的Key是唯一的，value是可以重复的（相同的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删除掉，然后再来进行重新插入

TreeMap 和 HashMap 的区别

Map底层结构	TreeMap	HashMap
底层结构	红黑树	哈希桶
插入/删除/查找时间复杂度	O(logN)	O(1)
是否有序	关于Key有序	无序
线程安全	不安全	不安全
插入/删除/查找区别	需要进行元素比较	通过哈希函数计算哈希地址
比较与覆写	key必须能够比较，否则会抛出 ClassCastException异常	自定义类型需要覆写equals和 hashCode方法
应用场景	需要Key有序场景下	Key是否有序不关心，需要更高的时间性能

2.3 Set

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

1. 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可以

TreeSet 和 HashSet 的区别

Map底层结构	TreeMap	HashMap
底层结构	红黑树	哈希桶
插入/删除/查找时间复杂度	O(logN)	O(1)
是否有序	关于Key有序	无序
线程安全	不安全	不安全
插入/删除/查找区别	按照红黑树的特性来进行插入和删除	先计算key哈希地址，然后进行插入和删除
比较与覆写	key必须能够比较，否则会抛出 ClassCastException异常	自定义类型需要覆写equals和 hashCode方法
应用场景	需要Key有序场景下	Key是否有序不关心，需要更高的时间性能

三、哈希表

3.1 概念

通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时不经过任何比较，一次直接从表中得到要搜索的元素的数据结构

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

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(HashTable)(或者称散列表)
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小

3.2 冲突

（1）概念

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

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”

（2）冲突避免

首先，由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，所以冲突的发生是必然的，我们能做的应该是尽量的降低冲突率

下面介绍两种避免冲突的方法

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

• 哈希函数设计原则：

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
  • 哈希函数计算出来的地址能均匀分布在整个空间中
  • 哈希函数应该比较简单

• 常见哈希函数

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

哈希桶，链表长度 = 8的时候，会变成一个红黑树，进一步提高效率（不然就要遍历链表了）

从1.8版本开始，用的是尾插法

第二种：负载因子调节

散列表的载荷因子定义：α = 填入表中的元素个数 / 散列表的长度
所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。
一般默认的的负载因子是0.75，所以每次插入一个元素，都要进行负载因子的计算，如果负载因子过大就要进行扩容

（2）冲突解决

一、闭散列

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

下面是两种找下一个空位置的方法

（1）线性探测

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

• 插入
  • 通过哈希函数获取待插入元素在哈希表中的位置
  • 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
• 缺陷
  • 采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
  • 缺陷是产生冲突的数据堆积在一块

（2）二次探测

• 缺陷
  • 空间利用率比较低，这也是哈希的缺陷
  • 删除也很麻烦

二、开散列/哈希桶（重点掌握）

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

1. 哈希桶，链表长度 = 8的时候，会变成一个红黑树，进一步提高效率（不然就要遍历链表了）
2. 变成红黑树时，红黑树插入的数据是要比较大小的，而此时比较大小，不是根据key比较大小，而是根据hashcode比较
3. 开散列中每个桶中放的都是发生哈希冲突的元素。
   开散列，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了

模拟实现

public class HashBucket {
    static class Node {
        private int key;
        private int value;
        private Node next;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    public Node[] array;
    public int usedSize;
    //默认的负载因子为0.75
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    public HashBucket() {
        this.array = new Node[10];
    }

    public void put(int key,int val) {
        Node node = new Node(key,val);
        int index = key % array.length;//
        //遍历index位置下方的链表
        Node cur = array[index];
        while (cur != null) {
            if(cur.key == key) {
                cur.value = val;
                return;
            }
            cur = cur.next;
        }
        //cur == null 没有这个key  那么 进行头插法
        node.next = array[index];
        array[index] = node;

        usedSize++;
        //计算负载因子
        if(loadFactor() >= DEFAULT_LOAD_FACTOR) {
            //扩容！！
            resize();
        }
    }

    //重新哈希原来的数据 ！！！
    private void resize() {
        //2倍扩容
        Node[] tmpArray = new Node[array.length * 2];
        //遍历原来的数组 下标的每个链表
        for (int i = 0; i < array.length; i++) {
            Node cur = array[i];
            while (cur != null) {
                Node curNext = cur.next;//需要记录下来 原来链表的下一个节点的位置
                int index = cur.key % tmpArray.length;//新数组的位置
                //采用头插法 放到新数组的index位置
                cur.next = tmpArray[index];//这里修改之后 cur的next已经变了
                tmpArray[index] = cur;
                cur = curNext;
            }
        }
        array = tmpArray;
    }


    private float loadFactor() {
        return usedSize*1.0f / array.length;
    }

    /**
     * 通过key值 返回value
     * @param key
     * @return
     */
    public int get(int key) {
        int index = key % array.length;//
        Node cur = array[index];
        while (cur != null) {
            if(cur.key == key) {
                return cur.value;
            }
            cur = cur.next;
        }
        return -1;
    }
}

public class HashBucket {
    static class Node {
        private int key;
        private int value;
        private Node next;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    public Node[] array;
    public int usedSize;
    //默认的负载因子为0.75
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    public HashBucket() {
        this.array = new Node[10];
    }

    public void put(int key,int val) {
        Node node = new Node(key,val);
        int index = key % array.length;//
        //遍历index位置下方的链表
        Node cur = array[index];
        while (cur != null) {
            if(cur.key == key) {
                cur.value = val;
                return;
            }
            cur = cur.next;
        }
        //cur == null 没有这个key  那么 进行头插法
        node.next = array[index];
        array[index] = node;

        usedSize++;
        //计算负载因子
        if(loadFactor() >= DEFAULT_LOAD_FACTOR) {
            //扩容！！
            resize();
        }
    }

    //重新哈希原来的数据 ！！！
    private void resize() {
        //2倍扩容
        Node[] tmpArray = new Node[array.length * 2];
        //遍历原来的数组 下标的每个链表
        for (int i = 0; i < array.length; i++) {
            Node cur = array[i];
            while (cur != null) {
                Node curNext = cur.next;//需要记录下来 原来链表的下一个节点的位置
                int index = cur.key % tmpArray.length;//新数组的位置
                //采用头插法 放到新数组的index位置
                cur.next = tmpArray[index];//这里修改之后 cur的next已经变了
                tmpArray[index] = cur;
                cur = curNext;
            }
        }
        array = tmpArray;
    }


    private float loadFactor() {
        return usedSize*1.0f / array.length;
    }

    /**
     * 通过key值 返回value
     * @param key
     * @return
     */
    public int get(int key) {
        int index = key % array.length;//
        Node cur = array[index];
        while (cur != null) {
            if(cur.key == key) {
                return cur.value;
            }
            cur = cur.next;
        }
        return -1;
    }
}

（3）冲突严重时的解决办法
刚才我们提到了，哈希桶其实可以看作将大集合的搜索问题转化为小集合的搜索问题了，那如果冲突严重，就意味着小集合的搜索性能其实也时不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：

1. 每个桶的背后是另一个哈希表
2. 每个桶的背后是一棵搜索树

3.3 其他

（1）性能分析

虽然哈希表一直在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的，也就是每个桶中的链表的长度是一个常数，所以，通常意义下，我们认为哈希表的插入/删除/查找时间复杂度是O(1)

（2）和java类集的关系

1. HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set
2. java 中使用的是哈希桶方式解决冲突的
3. java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）
4. java 中计算哈希值实际上是调用的类的 hashCode 方法，进行 key 的相等性比较是调用 key 的 equals 方法。所以如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值，必须覆写 hashCode 和 equals 方法，而且要做到 equals 相等的对象，hashCode 一定是一致的