Map和set (2)-CSDN博客

本文链接：https://blog.csdn.net/mmm174/article/details/126213745

思考：

1.对于任何一颗BST，最小值一定是叶子结点吗？

不一定是叶子结点，不断向左树递归查找，找到的第一个左子树为空的结点一定是当前BST的最小值。

2.BST中最大值一定位于右树的最右侧

我们不断递归地向右树查找，找到的第一个node.right== null 的结点就是最大值。

Hibber Deletion:在BST中删除一个左右子树都存在的结点，找到当前以58为根节点的前驱或者后继节点作为删除的新结点。

前驱：在以58为根的BST中最后一个小于58的结点（小于58的结点中最大的一个）53

后继：在以58为根的BST中第一个大于58的结点（大于58的节点中最小的一个）59


    //在BST中删除任意值
    public void remove(int val){
        root = remove(root,val);
    }

    private TreeNode remove(TreeNode root, int val) {
        //在当前root为根节点的BST中删除值为val的结点
        //返回删除后的新的根节点
        //边界条件
        if(root == null){
            //把树中所有节点都遍历完还没找到值为val的结点，就不存在值为val的结点
            throw new NoSuchElementException("BST 中没有值为" +val +"的结点");
        }else if(val <root.val){
            //此时应在左子树中找
            root.left = remove(root.left,val);
            return root;
        }else if(val >root.val){
            //此时在右树中找
            root.right = remove(root.right,val);
            return root;
        }else{
            //此时root.val == val
            //root是待删除的结点
            if(root.left == null){
                //只有右孩子，返回右孩子
                TreeNode right = root.right;
                root.right = root =null;
                size --;
                return right;
            }
            if(root.right == null){
                //此时右树为空，只有左孩子
                TreeNode left = root.left;
                root.left = root = null;//断开两根线
                size --;
                return left;
            }
            //此时说明root.left和root.right都不为空
            //Hibber Deletion
            TreeNode successor = minNode(root.right);//在比val大的节点中找出最小的一个
            successor.right = removeMin(root.right);
            //然后删除这个后继结点，将找出的后继结点的右子树作为新的结点
            successor.left = root.left;
            root.right = root.left = root = null;//断开两根线
            return successor;
        }
    }

为啥最后没有size --?

在右子树中删除后继结点的时候就已经size--了。

BST是非常高效的查询数据结构，但是BST也会在某些场景下出现退化的情况

eg.向BST中插入1 2 3 4 5 6 7 8 9

此时BST就退化为链表（单支树），查询效率就会退化为O(N).

为了避免在数据插入时，BST左右子树高度严重倾斜，引入了平衡树：

AVL:严格平衡，任意一个子树左右高度差不超过1BST永远不会退化为链表，性能保证是O(logN)

RBTree:黑结点严格平衡

这两个都是二分平衡搜索树。

哈希表实际上是通过数组衍生出来的，哈希表高效查找的奥秘就在于数组的随机访问特性。

哈希表是一个典型的以空间换时间的数据结构

1.遍历原集合，创建一个新数组，建立元素和索引的对应关系，当元素在集合中存在，我就讲新数组对应的索引的位置标记为true

2.判断一个数是否在原集合存在，只需要拿着这个数对应在新数组的索引位置是否为true，就能查询到是否存在。o(1）

所谓的哈希函数就是将任意的数据类型变为整型int后就可以作为数组的索引了。

假设现在的数据集是[1000,0,3000,10,-2,10000]这种跨度大的元素集合，有的元素本身值比较大，若采用一一对应的方式的话就得开辟长度至少100001的长度，非常浪费空间。

因此大部分场景下，我们需要将原数组的元素和数据的索引位置建立一个映射关系（哈希函数）

最常用的哈希方法“取模”

1.先将key取绝对值，对任意整数x & 0x7fffffff ,就是x取绝对值

2.将绝对值%10(区间的大小取决于我们取模数的大小)

有可能出现多个不同的key经过hash之后得到了相同的值，哈希冲突

哈希函数的设计原则：

1.不同的key值经过hash函数运算后得到的结果分布越均匀越好

一般模一个素数会得到一个比较均衡的值

2.稳定性：相同的key值经过N次哈希运算得到的值一定是相同的

哈希函数一般不需要我们自己设计，用现成的即可hashCode()

任意一个数据类型都可以通过hashCode方法转为整形

public class HashTest {
    public static void main(String[] args) {
        String str = "门门";
        Integer age = 18;
        Double c = 79.5;//这是一个包装类
        System.out.println(str.hashCode());
        System.out.println(age.hashCode());//必须要使用包装类才可以使用hashCode,
                              //如果使用的是int,就不能解析出hashCode
        System.out.println(c.hashCode());
    }
}

hashCode相同的对象equals一定相同吗？false

不同的key对应了相同的hash

equals相同的对象hashCode的值一定相同吗？true

以MD5为例，MD5一般给字符串进行hash运算

MD5的三大特点：

1.定长，无论输入的数据有多长，得到的MD5值得长度是固定的

2.分散，如果输入的数据稍微有点变化，得到的MD5值相差非常大

3.不可逆，根据任意值计算出的MD5值很容易，但是MD5值还原为原数据（难如登天），基本不可能（用在加密领域）