第八章_集合(2)_set集合&二叉树&红黑树

最新推荐文章于 2024-03-25 20:55:52 发布
最新推荐文章于 2024-03-25 20:55:52 发布
阅读量962 收藏
点赞数
分类专栏： JavaEE初级（一）Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq23001186/article/details/124043896
版权

目录

一、Set集合

  • Set集合概述和特点
    • 不可以存储重复元素，可以去除重复
    • 存取顺序不一致
    • 没有带索引的方法，不能使用普通for循环遍历，也不能通过索引来获取/删除set集合的元素
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class MySet1 {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("ccc");
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");
//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

二、TreeSet

  • TreeSet集合概述和特点：底层实现是红黑树
    • 不可以存储重复元素
    • 没有索引
    • 可以将元素按照规则进行排序
      • TreeSet()：根据其元素的自然排序进行排序
      • TreeSet(Comparator comparator) ：根据指定的比较器进行排序

如果想要使用TreeSet，需要制定排序规则

  • 案例：TreeSet集合来存储Integer类型
import java.util.TreeSet;

public class MyTreeSet1 {
    public static void main(String[] args) {
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(5);
        ts.add(3);
        ts.add(4);
        ts.add(1);
        ts.add(2);
        System.out.println(ts);
    }
}
  • 自然排序Comparable的使用
    • a）使用空参构造创建TreeSet集合：用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
    • b）自定义的Student类实现Comparable接口：自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
    • c）重写接口中的compareTo方法：重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
Student
public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

	//GET...SET...

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照对象的年龄进行排序
        //主要判断条件
        int result = this.age - o.age;
        //次要判断条件
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }
}
测试类
import java.util.TreeSet;

/**
 * TreeSet集合来存储Student类型
 */
public class MyTreeSet2 {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>();
        Student s1 = new Student("zhangsan",28);
        Student s2 = new Student("lisi",27);
        Student s3 = new Student("wangwu",29);
        Student s4 = new Student("zhaoliu",28);
        Student s5 = new Student("qianqi",30);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        System.out.println(ts);
    }
}
  • 比较器排序Comparator
    • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
    • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
    • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
	//GTT...SET...
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
  • 自然排序和比较器排序的总结：在使用的时候，默认使用自然排序，当自然排序不满足现在的需求时，必须使用比较器排序
    • 自然排序：自定义类实现Comparable接口，重写compareTo方法,根据返回值进行排序
    • 比较器排序：创建TreeSet对象的时候传递Comparator的实现类对象，重写compare方法，根据返回值进行排序
  • 两种方式中关于返回值的规则
    • 如果返回值为负数，表示当前存入的元素是较小值，存左边
    • 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
    • 如果返回值为正数，表示当前存入的元素是较大值，存右边
  • String类排序规则是Java已经写好的，需要修改就只能使用比较器排序修改
import java.util.Comparator;
import java.util.TreeSet;

public class MyTreeSet5 {
    public static void main(String[] args) {
//        TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                int result = o1.length() - o2.length();
//                result = result == 0 ? o1.compareTo(o2) : result;
//                return result;
//            }
//        });
        TreeSet<String> ts = new TreeSet<>(
                (String o1, String o2) -> {
                    int result = o1.length() - o2.length();
                    result = result == 0 ? o1.compareTo(o2) : result;
                    return result;
                }
        );
        ts.add("c");
        ts.add("ab");
        ts.add("df");
        ts.add("qwer");
        System.out.println(ts);
    }
}

三、二叉树

1、二叉树

TreeSet底层实现是红黑树

  • 二叉树的特点：二叉树中,任意一个节点的度要小于等于2
    • 节点：在树结构中，每一个元素称之为节点
    • 度：每一个节点的子节点数量称之为度

在这里插入图片描述
在这里插入图片描述

  • 二叉查找树的特点：二叉查找树,又称二叉排序树或者二叉搜索树
    • 每一个节点上最多有两个子节点
    • 左子树上所有节点的值都小于根节点的值
    • 右子树上所有节点的值都大于根节点的值

在这里插入图片描述

  • 二叉查找树添加节点规则：从根节点开始比较
    • 小的存左边
    • 大的存右边
    • 一样的不存

在这里插入图片描述

2、平衡二叉树

  • 平衡二叉树的特点
    • 二叉树左右两个子树的高度差不超过1（这样查询效率才是最高的）
    • 任意节点的左右两个子树都是一颗平衡二叉树
  • 平衡二叉树旋转触发时机：当添加一个节点之后,该树不再是一颗平衡二叉树
  • 平衡二叉树左旋：就是将根节点的右侧往左拉,原先的右子节点变成新的父节点,并把多余的左子节点出让,给已经降级的根节点当右子节点

在这里插入图片描述
在这里插入图片描述

  • 平衡二叉树右旋：就是将根节点的左侧往右拉,左子节点变成了新的父节点,并把多余的右子节点出让,给已经降级根节点当左子节点

在这里插入图片描述
在这里插入图片描述

3、平衡二叉树旋转的四种情况

  • 左左: 当根节点左子树的左子树有节点插入,导致二叉树不平衡：直接对整体进行右旋即可

在这里插入图片描述

  • 左右: 当根节点左子树的右子树有节点插入,导致二叉树不平衡：先在左子树对应的节点位置进行左旋,在对整体进行右旋

在这里插入图片描述

  • 右右: 当根节点右子树的右子树有节点插入,导致二叉树不平衡：直接对整体进行左旋即可

在这里插入图片描述

  • 右左:当根节点右子树的左子树有节点插入,导致二叉树不平衡：先在右子树对应的节点位置进行右旋,在对整体进行左旋

在这里插入图片描述

四、红黑树

  • 红黑树概念：红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构；1972年出现，当时被称之为平衡二叉B树；后来1978年被修改为如今的“红黑树”
    • 红黑树是一种特殊的二叉查找树，每一个节点或是红色的,或者是黑色的，根节点必须是黑色
    • 红黑树不是高度平衡的,它的平衡是通过"自己的红黑规则"进行实现的
  • 红黑树的红黑规则
    • a）每一个节点或是红色的,或者是黑色的
    • b）根节点必须是黑色
    • c）如果一个节点没有子节点或者父节点,则该节点相应的指针属性值为Nil,这些Nil视为叶节点,每个叶节点(Nil)是黑色的
    • d）如果某一个节点是红色,那么它的子节点必须是黑色(不能出现两个红色节点相连 的情况)
    • e）对每一个节点,从该节点到其所有后代叶节点的简单路径上,均包含相同数目的黑色节点

在这里插入图片描述

  • 红黑树添加节点的默认颜色：添加节点时,默认为红色,效率高

在这里插入图片描述

  • 红黑树添加节点后如何保持红黑规则

在这里插入图片描述

  • 案例：成绩排序案例
///学生类
public class Student implements Comparable<Student>{
    private String name;
    private int chinese;
    private int math;
    private int english;

    public Student() {
    }

    public Student(String name, int chinese, int math, int english) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }
	//GET...SET...
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", chinese=" + chinese +
                ", math=" + math +
                ", english=" + english +
                '}' + "总分为" + getSum();
    }

    public int getSum(){
        return chinese + math + english;
    }

    @Override
    public int compareTo(Student o) {
        //按照总分进行排序
        //int result = this.getChinese() + this.getMath() + this.getEnglish()
        int result = o.getSum() - this.getSum();
        //次要条件
        //总分一样，就比较语文成绩
        result = result == 0 ? o.getChinese() - this.getChinese() : result;
        //语文成绩一样，就比较数学成绩
        result = result == 0 ? o.getMath() - this.getMath() : result;
        //如果数学成绩一样，就比较英文成绩
        result = result == 0 ? o.getEnglish() - this.getEnglish() : result;
        //如果成绩都一样，则按照姓名进行排序
        result = result == 0 ? o.getName().compareTo(this.getName()) : result;
        return result;
    }
}
//测试类
import java.util.TreeSet;

public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Student>  ts = new TreeSet<>();
        Student s1 = new Student("dahei",80,80,80);
        Student s2 = new Student("erhei",90,90,90);
        Student s3 = new Student("xiaohei",100,100,100);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        for (Student student : ts) {
            System.out.println(student);
        }
    }
}

五、HashSet

  • HashSet集合概述和特点
    • 底层数据结构是哈希表
    • 不能保证存储和取出的顺序完全一致
    • 没有带索引的方法，所以不能使用普通for遍历
    • 由于是set集合，所以元素唯一
  • HashSet集合的基本应用
import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo1 {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("java");
        hs.add("java");
        Iterator<String> it = hs.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("=============================");
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

1、哈希值

  • 哈希值简介：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
  • 如何获取哈希值：Object类中的public int hashCode()：返回对象的哈希码值
  • 哈希值的特点：
    • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
    • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
      • 如果没有重写hashCode方法，那么是根据对象的地址值计算出的哈希值
      • 如果重写了hashCode方法，一般都是通过对象的属性值计算出哈希值
/Student类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
	
	//GET...SET...
	
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    //我们可以对Object类中的hashCode方法进行重写
    //在重写之后，就一般是根据对象的属性值来计算哈希值的。
    //此时跟对象的地址值就没有任何关系了。
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
/测试类
public class HashSetDemo2 {
    public static void main(String[] args) {
        Student s1 = new Student("xiaozhi",23);
        Student s2 = new Student("xiaomei",22);
        //因为在Object类中，是根据对象的地址值计算出来的哈希值。
        System.out.println(s1.hashCode());//1060830840
        System.out.println(s1.hashCode());//1060830840
        System.out.println(s2.hashCode());//2137211482
    }
}

2、哈希表

  • JDK8以前不包括8：数组+链表
  • JDK8以后包括8
    • 节点个数少于等于8个：数组+链表
    • 节点个数多于8个：数组+红黑树

在这里插入图片描述

在这里插入图片描述

  • HashSet1.8版本的存储流程

在这里插入图片描述

  • 案例：HashSet集合存储学生对象并遍历
    • 案例需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合；要求：学生对象的成员变量值相同，我们就认为是同一个对象
Student类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

	//GET...SET...

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
测试类
import java.util.HashSet;

public class HashSetTest1 {
    public static void main(String[] args) {
        HashSet<Student> hs = new HashSet<>();
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("xiaohei",23);
        Student s3 = new Student("xiaomei",22);
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        for (Student student : hs) {
            System.out.println(student);
        }
    }
}
无休止符
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java to Architect】HashSet TreeSet 集合 红黑树
ljinest
01-10 310
概论 Set集合继承了AbstractCollection集合，它的核心特点是没有重复元素，无序。 TreeSet集合（红黑树），在没有重复元素的基础上，还能够将元素进行排序储存。 Set 我将通过典型的HashSet来了解Set的特性。HashSet实现Set的方式是通过Hash表确保元素的唯一性。而Hash表中，又将分别进行两个动作来判断将要储存的元素是否唯一。 *hashCode()*方法 equals() 方法 在往HashSet内添加值时，会分别进行以上两个步骤。HashSet允许储存：
二叉树----set集合容器
Cynical丶Gary_博客
07-30 756
set集合容器实现了红黑树(Red-Black Tree)的平衡二叉搜索树的数据结构，在插入元素时，它会自动调整二叉树的排列，把该元素放到适当的位置，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有检点的键值；另外，还得确保根节点左子树的高度与右子树的高度相等，这样，二叉树的高度最小，从而搜索速度最快。 set容器不会插入重复相同键值的元素，而采取忽略处理。下面网上找的一张s
Map集合、散列表、红黑树介绍
weixin_33739523的博客
04-09 230
前言 声明，本文用得是jdk1.8 前面已经讲了Collection的总览和剖析List集合： Collection总览 List集合就这么简单【源码剖析】 原本我是打算继续将Collection下的Set集合的，结果看了源码发现：Set集合实际上就是HashMap来构建的！ 所以，就先介绍Map集合、散列表和红黑树吧！ 看这篇文章之前最好是有点数据结构的基础： Java实现单向链表 ...
JavaSE进阶笔记-集合02(Set,TreeSet,二叉树)
SUIT THUG!的博客
07-14 260
1.泛型 1.1泛型概述【理解】 泛型的介绍 ​ 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制 泛型的好处 把运行时期的问题提前到了编译期间 避免了强制类型转换 泛型的定义格式 <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V> 1.2泛型类【应用】 定义格式 修饰符 class 类名&
STL 小白学习（8） set 二叉树
aichao1257的博客
12-26 170
#include <iostream> using namespace std; #include <set> void printSet(set<int> s) { for (set<int>::iterator it = s.begin(); it != s.end(); it++) { c...
hashset集合及红黑树简单随手记
12-05
在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。
Java程序设计与数据结构第六章习题答案
11-05
Java的TreeSet和TreeMap类基于红黑树实现，是学习树结构的好例子。此外，AVL树和B树等平衡树的概念也是重要知识点。 5. **图**：图由顶点和边组成，可以表示复杂的关联关系。Java中没有内置的图类，但可以通过邻接...
第2章 前端1 ：数据结构和算法上
03-13
5. 树：分层结构，如二叉树、平衡树（AVL、红黑树），常用于查找和排序操作。 6. 图：节点和边构成，用于表示复杂的关系，如路由规划、社交网络分析。 了解并熟练运用这些数据结构，可以帮助开发者设计更高效的数据...
ProblemsOfAlgorithm20_2:为了在2020年下半年解决算法问题
03-17
2. **数据结构**：包括数组、链表、栈、队列、堆、树（二叉树、平衡树、B树、红黑树等）、图、哈希表等。理解这些数据结构的特性及其在解决问题时的应用是至关重要的。 3. **动态规划**：一种用于解决具有重叠子...
STL中的平衡二叉树（set)
羽的博客
01-04 637
STL中的平衡二叉树（set) 之前说了multiset 现在来说说set容器 set的用法 set 和 mulset 的区别在于容器里不能出现重复的元素 a 和b 重复 <=>“a 必须排在 b 前面” 和“b 必须排在a 前面” 都不成立。 set 插入元素可能不成功。（因为元素不能重复的原因，所以如果插入相同元素就会失败） set 用法示例： #include <cstdio> #include <iostream> #include <cstri
map和set(三)——红黑树
最新发布
m0_74515566的博客
03-25 830
enum(枚举)里存的是节点的颜色节点要有指向左节点、右节点、父节点的指针；节点存的值(数据)及节点的颜色RED,BLACK, _kv(kv){}初始化(构造)节点，三指针指向空；_kv(值or数据)取决于传的值，_col默认为红色为什么(插入)节点的颜色默认为红色呢？如果插入黑色节点就会破坏规则：每条路径上黑色节点的数量相同所以(插入)节点的默认颜色为红色2.2插入以下为简写：u uncle 叔叔p parent 父亲g grandfather 爷爷。
Java集合番外：红黑树
qq_41829867的博客
02-01 248
文章目录前言一、二叉查找树二、红黑树什么是红黑树呢？总结 前言 按照正常的逻辑介绍完List之后应该开始Set会不会有大佬认为我乱了，胡来？但是，我们阐述Set时我们必须先阐述HashMap，否则不方便阐述HashSet。所以我准备把Map提到Set之前，Map首先就是HashMap，而在Java8版本中HashMap是由数组+链表+红黑树。如果不了解红黑树，就无法进行下去，所以我抽一个单独的出来说一下，也是由于最近用了红黑树，所以比较熟悉，拿出
set/multiset容器（二叉树）
m0_64837135的博客
03-26 1128
所有的元素都会在插入时自动被排序。 set容器与multiset容器本质在底层结构是二叉树，头文件均为#include <set> set容器与multiset容器有什么区别？ set容器不允许容器中有重复的元素。 multiset容器允许容器有重复的元素。 #include <iostream> using namespace std; #include <set> //set/multiset void printSet(set<int> &
二叉树--TreeSet数据结构
baidu_37278726的博客
04-15 1532
TreeSet：底层数据结构是二叉树。 保证元素唯一性的依据，compareTo方法return  0。 判断元素和remove删除元素都是依据的compareTo返回的数值。 排序方式：让元素自身具备比较线，让元素实现Comparable接口，覆盖compareTo方法。 顺序是从小（-1）到大（1）排序得。 二叉树只认比较返回的是-1,0,1。-1往左边放，1往右边
set四个集合操作&&红黑树初识
theArcticOcean
07-20 1013
了解红黑树： 首先说说二叉查找树。二叉查找树的重要性质：任何节点的键值一定大于其左子树中每一个节点的键值，并小于其右子树中每一个节点的键值。在极端情况下，当所有节点位于一条链上时，二叉查找树的操作时间为O(N)。沿树的左边向下走，能够找到最小值。沿着树的右边走能够找到最大值。 和二叉搜索树一样，红黑树（一种特殊的二叉查找树）可以支持search，minimum，maximun,insert,d
STL之红黑树中的比较操作
dizuo的专栏
04-06 2126
stl set compare functor
LinkedHashSet_TreeSet的红黑树结构
weixin_57219176的博客
04-20 212
* LinkedHashSet继承自HashSet * 哈希表/链接表 * 1）元素唯一性（哈希表保证） * 2）有序性（存储和取出一致），链表保证 public class LinkedHashSetDemo { public static void main(String[] args) { //创建一个LinkedHashSet集合对象 LinkedHashSet<String>lsh=new LinkedHashSet&...
学习java的第三十二天，Set子接口中TreeSet类、二叉树、红黑树、Comparator比较器的使用
10719876
07-05 154
学习java的第三十二天，Set子接口中TreeSet类、二叉树、红黑树、Comparator比较器的使用
Java之TreeSet集合(二叉树实现)以及Comparable接口介绍
Daniel丶
10-22 2626
TreeSet 集合类是Set的子类 固有保持数据不重复的属性，除此之外还有一个独有的功能就是排序 当然常见的Integer，String类中java都将其比较机制写的很完善了 但对于自定义类而言 ，想要去排序就要自己去实现了 假设录入一个 Person类 (new Person(“aa”,100))其属性为姓名和年龄 假设要求我需要对集合中Person的年龄进行排序的话 我们该怎么办呢？ Tre...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

无休止符

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值