数据结构:Map和Set(1)

搜索树

概念

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

这棵树的中序遍历结果是有序的

接下来我们来模拟一棵二叉搜索树,和二叉树一样,定义左右结点,结点值和根结点

public class BinarySearchTree {
    static class TreeNode{
        public int val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(int val){
            this.val = val;
        }
    }
    public TreeNode root;
}

查找

拿目标值key与root进行比较,比root大的往右边搜索,比root小的往左边搜索;接着继续与左/右子树根结点比较,重复上面步骤

搜索代码

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

时间复杂度:

最好情况:完全二叉树,那时间复杂度为O(logN)

最坏情况:单分支二叉树,时间复杂度O(N)

插入

对于下方的二叉树,我们需要插入15

我们可以定义一个cur,负责遍历二叉树;定义一个parent记录子树的根结点位置

如果当前cur结点的值比目标插入的值小,就把parent定位到当前结点,把cur往右子树移动

如果cur值较大就向左子树移。cur负责帮助parent定位到目标值附近

定义一个node承载目标值,如果parent的值小于目标值就把node右插,反之则左插

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

拿这么一个列表来测试一下

array = {5,12,3,2,11,15}

正常画出来的图是这样的

测试debug后画出来的图一模一样😊

 删除

设待删除的结点是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

        if(cur.left == null){
            if(cur == root){
                root = parent.right;
            }else if(cur == parent.left){
                parent.right = cur.left;
            }else{
                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

        else if(cur.right == null) {
            if(cur == root){
                root = parent.left;
            }else if(cur == parent.left){
                parent.left = cur.left;
            }else{
                parent.right = cur.left;
            }
        }

第三种情况:cur.left != null && cur.right != null

我们逍遥删除cur位置这个40元素

首先确定的一点是,40的左子树比40都小,右子树比40都大

替换法:找一个数据来替换cur

1.确定cur这里将来要放的数据一定比左边都大,比右边都小

2.要么在左树里面找到最大的数值(左树最右边的数据);

要么就在右树里面找到最小的数值来替换(右树最左边的数据)

3.找到合适的数据之后,直接替换cur的值,然后删除那个合适的数据结点

        else{
            //找到合适的值(从右子树找最小值)
            //target负责找到合适值,targetParent负责记录target的双亲结点
            TreeNode targetParent = cur;
            TreeNode target = cur;
            while(target.left != null){
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            
            //删除target,因为已经到最左边了,所以直接让parent的左边 = target的右边
            //就算右边为空也没关系
            targetParent.left = target.right;
        }

其实这个代码还存在一个问题,如下图,我们找到50为最小值进行替换,替换完删除50的时候执行targetParent.left = target.right; 但是变成20改为55了,这明显不对劲

也就是说,上面的代码只适合targetParent.left = target的情况

遇到这种targetParent.right = target的情况,需要让targetParent的右边 = target的右边

代码修改(只修改删除target的部分)

            if(targetParent.left == target){
                targetParent.left = target.right;
            }else{
                targetParent.right = target.right;
            }

不想看分析可以直接看这

整个的代码:

    public void remove(int val){
        TreeNode cur = root;
        TreeNode parent = null;
        while(cur!=null){
            if(cur.val < val){
                parent = cur;
                cur = cur.right;
            }else if(cur.val > val){
                parent = cur;
                cur = cur.left;
            }else{
                //开始删除
                removeNode(cur,parent);
                }
            }
        }

    private void removeNode(TreeNode cur, TreeNode parent) {
        if(cur.left == null){
            if(cur == root){
                root = parent.right;
            }else if(cur == parent.left){
                parent.right = cur.left;
            }else{
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root){
                root = parent.left;
            }else if(cur == parent.left){
                parent.left = cur.left;
            }else{
                parent.right = cur.left;
            }
        }else{
            //找到合适的值(从右子树找最小值)
            //target负责找到合适值,targetParent负责记录target的双亲结点
            TreeNode targetParent = cur;
            TreeNode target = cur;
            while(target.left != null){
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;

            //删除target
            if(targetParent.left == target){
                targetParent.left = target.right;
            }else{
                targetParent.right = target.right;
            }
        }
    }

Map的使用

搜索

我们学过的搜索

1.直接遍历: --> O(N),速度较慢

2.二分查找:--> O(logN),但要求搜索的序列有序

上面的搜索都属于静态搜索

而现实中我们需要在查找时进行一些插入和删除操作,就需要用到Map和Set这两个适合动态查找的容器了

Map属于Key-Value 模型 Key-Value 模型比如:
统计文件中每个单词出现的次数,统计结果是每个单词都有与其对应的次数: < 单词,单词出现的次数 >
梁山好汉的江湖绰号:每个好汉都有自己的江湖绰号

 Map有两种形式,二叉搜索树和哈希表

        Map<String,Integer> map = new TreeMap<>();//二叉搜索树, 查找复杂度O(logN)
        Map<String,Integer> map1 = new HashMap<>();//哈希表, 查找复杂度O(1) 哈希表-->数组+列表+红黑树

方法

put设置key和对应的value 

get通过key来找到对应的值 

如果找不到就返回null

getOrDefault方法和get差不多,只不过找不到就默认返回自己设置的返回值

keySet获取所有的key

entrySet返回key-value的所有关系

Set<Map.Entry<String,Integer>> entrySet = map.entrySet();

而Set是所有Entry的集合

注意:

1.Map是一个接口,不能直接实例化对象,只能实例化其实现类TreeMap或HashMap

2.Map里的键值对中key是唯一的,但value是可以重复的,以最后一个value为准

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


Set的使用

Set属于 key 模型 key 模型比如:
有一个英文词典,快速查找一个单词是否在词典中
快速查找某个名字在不在通讯录中

方法

iterator方法,输出每个key,每行1个 

注意:

1.Set是继承自Collection的一个接口类

2.TreeSet的底层是TreeMap

3.实现Set接口的常用类有TreeSetHashSet,还有一个LinkedHashSetLinkedHashSet是在HashSet的基础上维护了一个双向链表来记录元素的插入次序。


哈希表

概念

顺序结构以及平衡树中,元素关键码与其存储位置之间没有对应的关系,因此在查找一个元素时,
必须要经过关键码的多次比较。搜索的效率取决于搜索过程中元素的比较次数
理想搜索方法:可以不经过比较,一次直接从表中得到要搜索的元素,通过该元素的存储位置和它的关键码之间建立一一映射的关系

这种函数叫做哈希函数:hash(key) = key % capacity

capacity是存储元素底层空间的大小

 哈希冲突:不同的关键字key,通过相同的哈希函数,得到相同的值

哈希冲突无法解决,只能降低冲突率

哈希函数的设计

合理的哈希函数可以降低冲突率

原则:

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

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

3.哈希函数比较简单

常见的哈希函数

直接订制法:取关键字的某个线性函数为散列地址

优点:简单、均匀
缺点:需要事先知道关 键字的分布情况
使用场景:适合查找比较小且连续的情况
  387. 字符串中的第一个唯一字符 - 力扣(LeetCode)
    public int firstUniqChar(String s) {
        int[] count = new int[26];
        for(int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            count[ch-'a']++;
        }
        for(int i = 0; i< s.length();i++){
            char ch = s.charAt(i);
            if(count[ch-'a'] == 1){
                return i;
            }
        }
        return -1;
    }

除留余数法

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

负载因子调节 

由图片我们可以知道负载因子越高,冲突率逐渐增加

填入表里面的元素已经是固定的情况下,为了使负载因子降低,我们只能让散列表扩容


冲突避免方法

闭散列

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

那么怎么找到这个“下一个”位置呢?

1.线性探测法:

比如我们要在这个线性表中放入44,14,24,34,54

44与4冲突了,探测到4下一个的位置时空的,就把44放进去,后面的14,24,34挨个放进去空位置,到了54,后面没有位置可以放了,返回到前面继续探测,找到0位置 

但是线性探测有个缺点,产生冲突的数据会堆在一块 

2.二次探测

或者

H0时通过散列函数对关键码key计算出来的位置,m是表的大小,i = 0,1,2,3....代表的是要插入的数据排在第几位

 这样明显不会堆在一起,而是均匀散开来了


开散列/哈希桶

又叫链地址法(开链法),采用数组+链表(+红黑树,当数组长度>64 && 链表长度 >=8 之后才会把链表变成红黑树)的方法,把冲突的元素采用尾插法插入被冲突元素的后面(JDK 1.7之前采用头插法,JDK 1.8之后采用尾插法)

数组的每个元素是链表的头节点


手搓一个哈希桶

初始化链表

每个结点需要有三个域,key,value和next

    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[] array;
    public int usedSize;//记录存放的有效数据

插入元素 

第一步:首先用cur进行遍历,遍历index下标的链表是否存在key,如果存在就更新value,遍历完还不存在就插入元素

    public void put(int key, int val){
        int index = key % array.length;
        //遍历index下标的链表是否存在key,如果存在就更新value,不存在就插入数据
        Node cur = array[index];
        while(cur!=null){
            if(cur.key == key){
                //更新value
                cur.val = val;
            }
            cur = cur.next;
        }
        //cur==null-->遍历完没有找到key
        // 头插法
        Node node = new Node(key,val);
        node.next = array[index];
        array[index] = node;
        usedSize++;
    }

第二步:计算负载因子

如果负载因子仍然大于默认的最低负载因子,则散列表需要进行扩容

    public static final float DEFAULT_LOAD_FACTOR = 0.75f;
    private float doLoadFactor(){
        return usedSize * 1.0f / array.length;
    }

面试题:可以这样进行扩容吗?

        if(doLoadFactor()>DEFAULT_LOAD_FACTOR){
            //扩容
            array = Arrays.copyOf(array, 2*array.length);
        }

都这么问了,那很明显是不行的😊

假设我们的11元素经过哈希之后放在插入到1下标这里

经过扩容之后,capacity发生了改变,变成了20

根据hash(key) = key % capacity,此时11%20 = 11

因为长度改变,原来冲突的元素放到了其他位置中去,所以这样扩容是不行滴

设置cur遍历原来的数组,每遍历到一个元素就纵向遍历链表的元素并进行头插法

代码: 

注意:这里为什么要用一个tmp保存cur.next呢?

所以我们用一个tmp来保存原来的纵向遍历时11元素的地址


获取元素

    public int get(int key){
        int index = key % array.length;
        Node cur = array[index];
        while(cur != null){
            if(cur.key == key){
                return cur.val;
            }
            cur = cur.next;
        }
        return -1;
    }

Map和Set其他一些注意事项

hashCode 

创建一个student类,放入学生身份id

class Student {
    public String id;

    public Student(String id) {
        this.id = id;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("61012345");
        Student student2 = new Student("61012345");
        System.out.println(student1.hashCode());
        System.out.println(student2.hashCode());
    }
}

我们发现打印出两种结果

在没有重写hashCode方法的时候,系统默认调取Object类里面的hashCode方法

虽然student1student2id属性值相同,但它们是不同的对象实例,因此它们在内存中有不同的地址。而Object里的hashCode使用对象的地址来生成哈希码,才有上面两种不同的结果

我们在student类里面重写一下方法(tips:可以点击generate-->equals() and hashCode()-->一路点下去创建方法)

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }

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

重写完打印结果

这个结果才满足x%len=hashcode这个算式,x相同,len确定,得到的结果就是一样的

🆗接下来我们想要重新写一下上面的哈希桶代码,跟之前手搓的不一样的是,重写的方法允许key传入一个类实例化对象而不是单纯能进行比较大小的数字

泛型类哈希桶代码

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>[] array;
    public int usedSize;
    public static final float DEFAULT_LOAD_FACTOR = 0.75f;

    public HashBuck2(){
        array = (Node<K,V>[]) new Node[10];//强转
    }
    public void put(K key, V val){
        int hash = key.hashCode();
        int index = hash % array.length;
        Node<K,V> cur = array[index];
        while(cur!=null){
            //引用类型不能用等号
            //if(cur.key == key){
            if(cur.key.equals(key)){
                //更新value
                cur.val = val;
            }
            cur = cur.next;
        }
        Node<K,V> node = new Node(key,val);
        node.next = array[index];
        array[index] = node;
        usedSize++;
    }
    public V getValue(K key){
        int hash = key.hashCode();
        int index = hash % array.length;
        Node<K,V> cur = array[index];
        while(cur != null){
            if(cur.key.equals(key)){
                return cur.val;
            }
            cur = cur.next;
        }
        return null;
    }
}

测试:

问题:hashCode和equals区别

一个例子带你看明白:

⚠以后在写自定义对象的时候建议把equals和hashCode重写一下

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/127758.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【Java】本地开发环境正常、测试或生产环境获取的文件路径不对的问题

引 Java 中经常获取本地文件或者resource下的文件&#xff0c;要获取文件&#xff0c;首先要获得本地路径。 Java 本身或一些开源工具包都提供了很多获取路径的方法。但使用时经常遇到本地开发环境正常、测试或生产环境获取的文件路径不对的问题。 本文将列出几种常见的获取…

盘点那些开发中经常用到的git命令

入职第一天 配置邮箱账号 git config —global user.email "XXXX" git config —global user.name "XXXX" 生成公钥 ssh-keygen -t rsa -C "你的邮箱"生成的文件默认在c盘:/用户/当前用户/.ssh文件夹下&#xff0c;也可以指定文件 打开git网页&…

【正点原子STM32连载】 第四十九章 SD卡实验 摘自【正点原子】APM32F407最小系统板使用指南

1&#xff09;实验平台&#xff1a;正点原子stm32f103战舰开发板V4 2&#xff09;平台购买地址&#xff1a;https://detail.tmall.com/item.htm?id609294757420 3&#xff09;全套实验源码手册视频下载地址&#xff1a; http://www.openedv.com/thread-340252-1-1.html## 第四…

对Mysql和应用微服务做TPS压力测试

1.对Mysql 使用工具&#xff1a;mysqlslap工具 使用命令&#xff1a; mysqlslap -uroot pGG8697000!#--auto generate sql -auto generate sql-load typemixed-concurrency100,200 - number of queries1000-iterations10 - number-int-cols7 - number-charcols13auto genera…

105.am40刷机(linux)折腾记1-前期的准备工作1

前段时间在某鱼上逛的时候&#xff0c;发现一款3399的盒子只要150大洋&#xff0c;内心就开始澎拜&#xff0c;一激动就下手了3台&#xff0c;花了450大洋&#xff08;现在想想&#xff0c;心都碎了一地&#xff09;。 然后自己又来来回回折腾了几天&#xff0c;目前能跑上fire…

NodeJs - 集合对象序列化问题

NodeJs - 集合对象序列化问题 一. 集合对象的序列化问题1.1 Map 和 Object 的区别1.2 Map 的相关转换Map 和 Array 互转Map 和 Object 互转 1.3 Set 的相关转换Set 和 Array 互转 一. 集合对象的序列化问题 案例如下&#xff1a;我们创建一个Map和一个Set集合&#xff0c;并用…

6、规划绩效域

1、变更 &#xff08;1&#xff09;变更有哪几种原因&#xff08;类型&#xff09;&#xff1f; 纠正措施&#xff08;比如进度落后了&#xff0c;我们会有赶工和快速跟进的措施&#xff09; 缺陷补救 预防措施 更新措施 2、变更的目的和变更控制流程的意义 考点1&#…

PSP - 蛋白质复合物结构预测 Template Pair 特征 Mask 可视化

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/134333419 在蛋白质复合物结构预测中&#xff0c;在 TemplatePairEmbedderMultimer 层中 &#xff0c;构建 Template Pair 特征的源码&#xff0c…

字符串取出多余空格的三种方法

151.翻转字符串里的单词 力扣题目链接(opens new window) 这个题的解题思路如下&#xff1a; 移除多余空格将整个字符串反转将每个单词反转 这个题的难点是去除多余的空格&#xff0c;下面我将详细讲解一下去除多余空格的几种方法。 第一种方法是逐个字符的去遍历&#xff…

CentOS 7 双网卡绑定热备 —— 筑梦之路

为什么需要&#xff1f; 1. 增强网络的可靠性 2. 保障服务的可持续性 3. 降低网卡故障带来的不良影响 有哪些模式&#xff1f; 模式0&#xff1a;轮询策略&#xff08;round robin&#xff09;&#xff0c;mode0&#xff0c;优点&#xff1a;流量提高一倍缺点&#xff1a;需要接…

Pytorch实战教程(一)-神经网络与模型训练

0. 前言 人工神经网络 (Artificial Neural Network, ANN) 是一种监督学习算法,其灵感来自人类大脑的运作方式。类似于人脑中神经元连接和激活的方式,神经网络接受输入,通过某些函数在网络中进行传递,导致某些后续神经元被激活,从而产生输出。函数越复杂,网络对于输入的数…

UE5蓝图接口使用方法

在内容区右键创建蓝图接口 命名自定义&#xff08;可以用好识别的&#xff09; 双击打开后关闭左边窗口 右键函数 -- 重命名 -- 名称自定义&#xff08;用好记的&#xff09; 点击下边输入后面的 号创建一个变量 点击编译并保存 在一个蓝图类里面 -- 点击类设置 在右侧已实现的…

修改Android Studio默认的gradle目录

今天看了一下&#xff0c;gradle在C盘占用了40多G。我C盘是做GHOST的&#xff0c;放在这里不方便。所以就要修改。 新建目录名&#xff08;似乎无必要&#xff09; ANDROID_SDK_HOMEG:\SOFTWARES\android-sdk GRADLE_USER_HOMEG:\SOFTWARES\.gradle 修改目录 File->Setti…

Html 引入element UI + vue3 报错Failed to resolve component: el-button

问题&#xff1a;Html 引入element UI vue3 &#xff0c;el-button效果不出来 <!DOCTYPE html> <html> <head><meta charset"UTF-8"><!-- import Vue before Element --> <!-- <script src"https://unpkg.com/vue2/dist…

nginx https 如何将部分路径转移到 http

nginx https 如何将部分路径转移到 http 我有一个自己的网站&#xff0c;默认是走的 https&#xff0c;其中有一个路径需要走 http。 实现 在 nginx 的配置文件 https 中添加这个路径&#xff0c;并添加一个 rewrite 的指令。 比如我需要将 tools/iphone 的路径转成 http&am…

Python使用腾讯云SDK实现对象存储(上传文件、创建桶)

文章目录 1. 开通服务2. 创建存储桶3. 手动上传文件并查看4. python上传文件4.1 找到sdk文档4.2 初始化代码4.3 region获取4.4 secret_id和secret_key获取4.5 上传对象代码4.6 python实现上传文件 5 python创建桶 首先来到腾讯云官网 https://cloud.tencent.com/1. 开通服务 来…

Java枚举类的使用

说明: 根据设计图抽象的枚举类,一张模板背景图(会改变),二维码(传入参数生成),一个关闭的icon(固定不变) 设计图如下 枚举类 去除重复模板后共五个,根据需求编写枚举类如下,url则对应不同的模板,编写成后台人员的可配置项, public enum ImageTemplateEnum {PURCHASE("p…

Python 实践

文章目录 一、HttpRequests 一、Http Requests python——Request模块

Ionic组件 ion-list ion-list-header

1 ion-list 列表由多行项目组成&#xff0c;这些项目可以包含 text, buttons, toggles, icons, thumbnails等。列表通常包含具有类似数据内容的项目&#xff0c;如 images and text。 列表支持多种交互&#xff0c;包括滑动项目以显示选项、拖动以重新排列列表中的项目以及删除…

GCC + Vscode 搭建 nRF52xxx 开发环境

在 Windows 下使用 GCC Vscode 搭建 nRF52xxx 开发环境 ...... by 矜辰所致前言 最近有遇到项目需求&#xff0c;需要使用到 Nordic 的 nRF52xxx 芯片&#xff0c;还记得当初刚开始写博文的时候的写的 nRF52832 学习笔记&#xff0c;现在看当时笔记毫无逻辑可言&#xff0c…