JAVA笔记 ------ 比较器和二叉树练习

最新推荐文章于 2024-05-20 20:48:49 发布
最新推荐文章于 2024-05-20 20:48:49 发布
阅读量142 收藏
点赞数
分类专栏： JAVA 文章标签： 二叉树 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43514659/article/details/113857976
版权
本文介绍了Java中Comparable接口和Comparator类在对象排序中的应用，讲解了如何使用它们对Person对象数组进行排序。此外，还探讨了二叉树结构，特别是二叉搜索树的插入和删除操作，以及数据结构转换为数组的方法。文章通过实例代码详细展示了其实现过程，强调了数据结构选择对效率的影响，并提到了红黑树作为更高级的平衡二叉树概念。
摘要由CSDN通过智能技术生成

比较器和二叉树

比较器

  • 所谓的比较器就是我们进行大小关系的一个判断！
  • 比较器还能对对象数组进行排序，但是排序需要用到比较器的。
  • 而其中数组的Arrays类里面的sort方法就可以进行排序，但是想要进行sort方法进行排序，必须使用的类里面要完成比较器的比较方法，才可以使用sort排序，否则就会报错。

在这里插入图片描述

  • 就是要实现Comparable接口里面的compareTo方法，代码如下：
import java.lang.reflect.Array;
import java.util.Arrays;

class Person implements Comparable<Person>{
    private String name;
    private int age;
    public Person(String name,int age){
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString(){
        return "【person对象】姓名：" + this.name + "、年龄：" + this.age;
    }

    @Override
    public int compareTo(Person o) {
        return this.age - o.age;
    }
}
public class 比较器练习 {
    public static void main(String[] args) {
        Person [] ans = new Person[]{
                new Person("小明",100),
                new Person("小红",80),
                new Person("小白",60),
                new Person("小黑",20)
        };
        Arrays.sort(ans);
        System.out.println(Arrays.toString(ans));
    }
}
  • 我们可以知道的是，如果Person类没有对compareTo方法进行实现的话，主函数里面的对象数组是无法完成排序的。
  • 所以，如果以后遇到了对象数组排序，那么一定要使用Comparable接口来实现排序；

Comparator

  • 属于一种挽救的排序功能，在后期无法对类进行修改的时候，可以使用；

在这里插入图片描述

  • 可利用这个类进行排序规则的定义！
  • 代码如下：
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;

class PersonComparator implements Comparator<Person>{
    @Override
    public int compare(Person person1, Person person2) {
        return person1.getAge() - person2.getAge();
    }
}
class Person {
    private String name;
    private int age;
    public Person(String name,int age){
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString(){
        return "【person对象】姓名：" + this.name + "、年龄：" + this.age + "\n";
    }
}
public class 比较器练习 {
    public static void main(String[] args) {
        Person [] ans = new Person[]{
                new Person("小明",100),
                new Person("小红",80),
                new Person("小白",60),
                new Person("小黑",20)
        };
        Arrays.sort(ans,new PersonComparator());
        System.out.println(Arrays.toString(ans));
    }
}
  • 这就是挽救型的排序比较；
  • 但是呢，这边建议，如果不是必须的情况下，还是使用第一种Comparable接口会比较好一点。

面试题：请解释Comparable与Comparator两个接口的区别？

  • java.lang.Comparable是在类定义的时候实现的父接口，主要用于比较排序定义排序规则，里面也只有一个compareTo方法。
  • java.util.Comparator是挽救型的比较器操作，需要设置单独的比较器规则类实现排序里面有compare方法。

二叉树结构

  • 在进行链表结构学习的时候呢，对于每一种操作他们的复杂度都是O(n)，那么在30以内的时候还能接受，但是当里面的数据变得很大的时候，那么复杂度就会直线上升。所以，我们只能够换数据结构，那么二叉树就是解决问题的方法，他可以将复杂度调至到O(logn)。
  • 这个我们还是可以接受的。
  • 那么二叉树的实现原理如下：

取第一个数据为保存的根节点，小于或等于根节点的节点要放在根节点的左子树，而大于节点的数据，要放在该节点的右子树。

在这里插入图片描述

  • 那么实现二叉树的处理中最为关键的就是数据的保存，那么数据的保存一定要有比较器的支持，而且比较器的我们首选的应该是Comparable接口的实现。

二叉树的实现


import java.util.Arrays;

class BinaryTree <T extends Comparable<T>> {
    private class Node {
        private Comparable<T> data;     //存放Comparable，可以进行比较
        private Node parent;
        private Node right;
        private Node left;
        public Node(Comparable<T> data){  //构造方法直接进行数据的存储
            this.data = data;
        }
        // Node内部类增加节点addNode方法
        public void addNode(Node newNode){
            if(newNode.data.compareTo( (T)this.data ) <= 0){
                if(this.left == null){
                    this.left = newNode;
                    newNode.parent = this;
                }else{
                    this.left.addNode(newNode);
                }
            }else{
                if(this.right == null){
                    this.right = newNode;
                    newNode.parent = this;
                }else{
                    this.right.addNode(newNode);
                }
            }
        }
        // Node内部类数据转换成数组toArrayNode方法
        public void toArrayNode(){
            if(this.left != null){
                this.left.toArrayNode();
            }
            BinaryTree.this.returnData[BinaryTree.this.foot ++ ] = this.data;
            if(this.right != null){
                this.right.toArrayNode();
            }
        }

    }
    /* -------------- 以下是二叉树的的功能实现 ------------ */
    private Node root;          //保存的根节点
    private int count;          //保存数据的个数
    private int foot = 0;
    private Object [] returnData;

    public void add(Comparable<T> data){
        if(data == null){
            throw new NullPointerException("保存的数据不允许为空");
        }
        Node newNode = new Node(data);
        if(this.root == null){
            this.root = newNode;
        }else{
            this.root.addNode(newNode);
        }
        this.count ++ ;
    }
    public Object [] toArray(){
        if(this.count == 0){
            return null;
        }
        this.returnData = new Object[this.count];
        this.foot = 0;
        this.root.toArrayNode();
        return returnData;
    }
}
public class 二叉树练习 {
    public static void main(String[] args) {
        BinaryTree<Person> tree = new BinaryTree<Person>();
        tree.add(new Person("小黑",20));
        tree.add(new Person("小红",30));
        tree.add(new Person("小白",40));
        tree.add(new Person("小绿",60));
        tree.add(new Person("小蓝",50));
        tree.add(new Person("小灰",100));
        System.out.println(Arrays.toString(tree.toArray()));
    }
}
  • 我们采用内部类的i形式，就可以完成了二叉数的基本实现了，二叉数在保存完节点以后，在内部里面就会完成排序。所以输出的就是有序的。

二叉树的数据删除

二叉树的数据删除是非常复杂的，因为考虑的东西挺多的，如下：

  • 情况1 ：如果删除的节点没有子节点，那么就可以直接删除。

在这里插入图片描述

  • 情况2 ：如果待删除的节点只有一个子节点，那么直接删除，用它的子节点去替换它。
  • 但是这里要考虑两种情况，一个是这个唯一的子节点是左子节点，还有就是右子节点。但是删除的方式相同

在这里插入图片描述

  • 情况3 ：如果删除的节点里面有两个子节点，先直接删除节点，然后用其右节点的最后的左节点进行顶包。

在这里插入图片描述

  • 这就是删除数据的三种情况了，我们下面进行代码完成：
import jdk.nashorn.internal.ir.BinaryNode;

import java.util.Arrays;

class BinaryTree <T extends Comparable<T>> {
    private class Node {
        private Comparable<T> data;     //存放Comparable，可以进行比较
        private Node parent;
        private Node right;
        private Node left;

        public Node(Comparable<T> data) {  //构造方法直接进行数据的存储
            this.data = data;
        }

        // Node内部类增加节点addNode方法
        public void addNode(Node newNode) {
            if (newNode.data.compareTo((T) this.data) <= 0) {
                if (this.left == null) {
                    this.left = newNode;
                    newNode.parent = this;
                } else {
                    this.left.addNode(newNode);
                }
            } else {
                if (this.right == null) {
                    this.right = newNode;
                    newNode.parent = this;
                } else {
                    this.right.addNode(newNode);
                }
            }
        }

        // Node内部类数据转换成数组toArrayNode方法
        public void toArrayNode() {
            if (this.left != null) {
                this.left.toArrayNode();
            }
            BinaryTree.this.returnData[BinaryTree.this.foot++] = this.data;
            if (this.right != null) {
                this.right.toArrayNode();
            }
        }
        //Node内部类判断数据是否存在   （可以省略）
        public boolean containsNode(Comparable<T> data) {
            if(data.compareTo((T)this.data) == 0){
                return true;
            }else if(data.compareTo((T)this.data) < 0){
                if(this.left != null){
                    return this.left.containsNode(data);
                }else {
                    return false;
                }
            }else {
                if(this.right != null){
                    return this.right.containsNode(data);
                }else{
                    return false;
                }
            }
        }
        //Node类，返回查找到的节点
        public Node getRemoveNode(Comparable<T> data){
            if(data.compareTo((T)this.data) == 0){
                return this;
            }else if(data.compareTo((T)this.data) < 0){
                if(this.left != null){
                    return this.left.getRemoveNode(data);
                }else{
                    return null;
                }
            }else {
                if(this.right != null){
                    return this.right.getRemoveNode(data);
                }else{
                    return null;
                }
            }
        }
    }
    /* -------------- 以下是二叉树的的功能实现 ------------ */
    private Node root;          //保存的根节点
    private int count;          //保存数据的个数
    private int foot = 0;
    private Object [] returnData;

    //BinaryTree类的增加数据方法
    public void add(Comparable<T> data){
        if(data == null){
            throw new NullPointerException("保存的数据不允许为空");
        }
        Node newNode = new Node(data);
        if(this.root == null){
            this.root = newNode;
        }else{
            this.root.addNode(newNode);
        }
        this.count ++ ;
    }
    //BinaryTree类的数据转换成数组方法
    public Object [] toArray(){
        if(this.count == 0){
            return null;
        }
        this.returnData = new Object[this.count];
        this.foot = 0;
        this.root.toArrayNode();
        return returnData;
    }
    //BinaryTree类判断数据是否存在
    public boolean contains(Comparable<T> data){
        if(this.count == 0)return false;
        return this.root.getRemoveNode(data) != null;
    }
    //BinaryTree类返回二叉数的大小
    public int getCount(){
        return this.count;
    }
    //BinaryTree类的数据删除方法
    public void remove(Comparable<T> data){
        if(this.root == null){
            return ;
        }else{
            if(this.root.data.compareTo((T)data) == 0){
                Node moveNode = this.root.right;
                while(moveNode.left != null){
                    moveNode = moveNode.left;
                }
                moveNode.left = this.root.left;
                moveNode.right = this.root.right;
                moveNode.parent.left = null;
                this.root = moveNode;
                this.count --;
            }else{
                Node removeNode = this.root.getRemoveNode(data);
                if(removeNode != null){
                    this.count -- ;
                    //情况一
                    if(removeNode.left == null && removeNode.right ==null){
                        if(removeNode.parent.left != null && removeNode.data.compareTo((T)removeNode.parent.left.data) == 0){
                            removeNode.parent.left = null;
                            removeNode.parent = null;
                        }else{
                            removeNode.parent.right = null;
                            removeNode.parent = null;
                        }
                    }else if(removeNode.left != null && removeNode.right == null){  //情况二_1
                        if(removeNode.parent.left != null && removeNode.data.compareTo((T)removeNode.parent.left.data) == 0){
                            removeNode.parent.left = removeNode.left;
                            removeNode.left.parent = removeNode.parent;
                            removeNode.parent = null;
                        }else{
                            removeNode.parent.right = removeNode.left;
                            removeNode.left = removeNode.parent;
                            removeNode.parent = null;
                        }
                    }else if(removeNode.left == null && removeNode.right != null){  //情况二_2
                        if(removeNode.parent.left != null && removeNode.data.compareTo((T)removeNode.parent.left.data) == 0){
                            removeNode.parent.left = removeNode.right;
                            removeNode.right = removeNode.parent;
                            removeNode.parent = null;
                        }else{
                            removeNode.parent.right = removeNode.right;
                            removeNode.right = removeNode.parent;
                            removeNode.parent = null;
                        }
                    }else{
                        Node moveNode = removeNode.right;
                        while(moveNode.left != null){
                            moveNode = moveNode.left;
                        }
                        if(removeNode.data.compareTo((T)moveNode.parent.data) == 0){
                            moveNode.parent.right = moveNode.right;
                        }else{
                            moveNode.parent.left = moveNode.right;
                        }
                        //判断要删除的节点是在他父亲节点的左边还是右边
                        if(removeNode.parent.left != null && removeNode.parent.left.data.compareTo((T)removeNode.data) == 0){
                            removeNode.parent.left = moveNode;
                        }else{
                            removeNode.parent.right = moveNode;
                        }
                        moveNode.right = removeNode.right;
                        moveNode.left = removeNode.left;
                    }
                }
            }
        }
    }
}
public class 二叉树练习 {
    public static void main(String[] args) {
        BinaryTree<Person> tree = new BinaryTree<Person>();
        Person ans1 = new Person("小白",80);
        Person ans2 = new Person("小黑",50);
        Person ans3 = new Person("小红",90);
        Person ans4 = new Person("小绿",10);
        Person ans5 = new Person("小蓝",60);
        Person ans6 = new Person("小灰",85);
        Person ans7 = new Person("aa",95);
        tree.add(ans1);
        tree.add(ans2);
        tree.add(ans3);
        tree.add(ans4);
        tree.add(ans5);
        tree.add(ans6);
        tree.add(ans7);
        tree.add(new Person("小青",55));
        tree.add(new Person("小青",65));
        tree.remove(new Person("xaio",50));
        System.out.println(Arrays.toString(tree.toArray()));
        System.out.println(tree.getCount());
    }
}
  • 说实在话，这个删除数据是真的把我搞哭了，搞了一个下午；
  • 第三种情况，思维固化了，最最最主要的是，视频老师没有备课，导致出现了好多bug，最后还是自己把他撸出来了，害，太累了，我要去吐槽；

红黑树原理分析

  • 这里重点理解，害，冲冲冲冲；
  • 红黑树呢，在本质上面，他是又给二叉查找树，但是他在二叉查找树的原有基础上面添加了一个标记。同时具有一定的规则，这些规则使得二叉树，能够保存平衡。

在这里插入图片描述

  • 那么他有什么特点呢，让我们来看看把，这可是很重要的，详细理解哦！！！

在这里插入图片描述

在这里插入图片描述

  • 这个还是太负责了，下次单独列一篇写。咳咳。。。
木木不会
关注
专栏目录
java 二叉树比较_关于二叉树比较的算法
weixin_31440053的博客
02-28 334
1、实体类/*** TreeNode必须包含三个部分* 1、节点值* 2、左节点(叶子节点可以没有)* 3、右节点(叶子节点可以没有)*/public class TreeNode {int val = 0;TreeNode left = null;TreeNode right = null;public TreeNode(int val) {this.val = val;}}1、算法实现类pub...
JAVA进阶的基础知识快速通过---自学笔记（二）
测试领域专家，多领域测试技术、管理、工具都略懂，略懂一二
04-23 651
温故而知新---陆续学习陆续更新中，你有更好的记忆和学习方法，请在评论区提出来大家一起交流,认真看完，一行行代码备注看完看懂，保证学会，学不会找我。 前言： 代码学完发现很简单，很多初学者搞不明白什么这个那个，其实是没有把概念记住，没有那么多为什么，为什么就这样做，就像小时候学数学，有很多的公式，刚开始学，我们只要死记公式，然后多练习，练习多了就不需要公式了，有时口算都能出来，到现在也不需要去...
初识JAVA：Java类库之比较器（重点）
数字成都
04-02 216
比较器（重点） 如果现在要想为一组对象进行排序，那么必须有一个可以区分出对象大小的关系操作，而这个操作在Java之中就是利用比较器完成的。常用比较器：Comparable（核心） 如果要为对象指定比较规则，那么对象所在的类必须实现Comparable接口，下面首先来看一下这个接口的定义： public interface Comparable<T> { public int comp...
TreeSet (比较器)
dingjingchao的博客
11-14 582
TreeSet:可以对Set集合中的元素进行排序
最大搜索二叉树的大小
yaogepila的博客
05-24 252
问题 给定一个二叉树，求它的最大搜索二叉树的大小 解决思路： 分成三种情况来考虑： 当前节点的左子树是搜索二叉树，而右节点并不是搜索二叉树；或者左节点的最大搜索二叉树的大小大于右节点的最大搜索二叉树的大小，那么此时最大的搜索二叉树就是它的左子树； 当前节点的右子树是搜索二叉树而左节点不是搜索二叉树；又或者左节点的最大搜索二叉树的大小小于右节点的最大搜索二叉树的大小，那么此时最大的搜索二叉树就是它的右子树； 当前节点的左子树和右子树都是搜索二叉树，并且当前节点的值大于左子树的最大搜索二叉树的最大值，小于右子
比较器（Comparable、Comparator）类及 二叉树的排序算法！！
韩世雷 程序员专栏
08-22 3949
之前Arrays 类中存在sort() 方法， 此方法可以直接对 对象数组进行排序。  1.Comparable接口 可以直接使用java.util.Arrays 类进行数组的排序操作，但对象所在的类必须实现Comparable 接口，用于指定排序接口。 Comparabl
java学习2--基础笔记练习
qq_51186720的博客
03-04 1868
内部类的优点是它属于外部类的一个成员，与成员变量和成员方法一样，可以很方便的访问外部类定义的成员变量和成员方法，而且不用在外面额外增加一个类的定义。
java函数编程-黑马学习笔记
最新发布
m0_73476251的博客
05-20 961
current（）。iterate（1，）第一个传的是初始的值 第二个传的是一个函数对象 intUnaryOperator 参数是int类型的 参数只有一个 参数和返回值的类型是统一的 都是基本类型的int。因为可能这一串数据中根本没有偶数 optional是可选的意思可以去用orElse去指定一个默认值 -----------------------》reduce（new Hero（“-”），-1，（h1，h2）-》h1.strength（）》h2.streng（）？
Java笔记--集合
peixiaoge的博客
10-31 229
1.用来存储对象的一种常见方式   2.集合的特点 （1）集合只用来存储对象 （2）集合的长度是可变的 （3）集合可以存储不同类型的对象   3.为什么会出现这么多的容器呢 因为每一个容器对数据的存储方式都不同，这个存储方式就称为数据结构   4.集合中存储的都是对象的引用（地址）   5.迭代器（通常用来遍历集合） 其实就是集合取出元素的方式 取出方式被定义成了内部类...
Java学习笔记-集合
Aboil的博客
05-18 142
Collection集合 Collection接口 集合与数组 使用数组的局限性 如果要存放多个对象，可以使用数组，但是数组有局限性，比如 声明长度是10的数组，不用的数组就浪费了超过10的个数，又放不下。 ArrayList存放对象 为了解决数组的局限性，引入容器类的概念。 最常见的容器类就是ArrayList 容器的容量"capacity"会随着对象的增加，自动增长 只需要不断往容器里增加元素即可，不用担心会出现数组的边界问题。 集合框架 List 特点：有索引、可以存储重复元素，存储有序.
【4-3】《Java中所有集合》——链表和二叉树、Collection、List、Set、Map、Iterator迭代器、集合在JDK9中的新特性
程序媛乐园
10-04 359
此文包含Java中所有集合知识点：使用方式和代码，还有各种注意事项集合一、类集概述二、链表和二叉树1、链表2、二叉树三、常见数据结构1、栈2、队列3、数组4、链表5、红黑树四、Collection接口（重点）1、List接口（重点）1.ArrayList集合（重点）2.Vector集合（重点）3.ArrayList类与Vector类的区别（重点）4.LinkedList集合（理解）2、Set接口（重点）1.HashSet集合（重点）2.TreeSet集合（重点）3.TreeSet与Comparable（重点
算法学习 （门徒计划）3-2 哈希表与布隆过滤器及经典问题 学习笔记
ex_xyz的博客
07-08 1448
算法学习 （门徒计划）3-2 哈希表与布隆过滤器及经典问题 学习笔记 - 学习哈希思想 - 重点讲一种特殊的哈希表布隆过滤器的实现方式。 - 学习哈希表的应用场景 - 期望通过本课学习对哈希表有一个整体的概念认识
算法学习 （门徒计划）1-3 递归与栈 学习笔记
ex_xyz的博客
03-30 1712
3月18日，开课吧门徒计划算法课第三讲学习笔记。 本课讲递归和栈。
JAVA复习笔记
准备23考研。不定期更新考研知识
07-26 2079
待补充
第1章 Java 主方法中的顺序结构
qq_43514659的博客
05-12 7342
前言 咳咳，你们开学了吗，反正我没有，害，不能一直颓废下去呢，所以呢，我觉得针对Java实训做一次全面的复习，一共12章，希望木木能都坚持下来，啊哈哈哈哈哈哈哈。 第一关：简单的无输入输出给定图案 咳咳，样式如图： public class Text1 { public static void main(String[] args) { System.out.println(" *"); System.out.println(" ***"); System.out.printl
Java学习-----面向对象
qq_43514659的博客
03-08 3063
“面向对象”的编程思想 那么，何为面向对象的编程思想呢 首先哈，这东西，不是你一下子就能顿悟滴，而是渐悟出来滴。可能大家听完这个后便觉得自己明白了，但是回头一想，好像什么都妹明白，一直处于这种状态。直到你不断的去写这个Java代码，在这个写的过程当中，你便会渐渐领悟了。你就会发现，原来的你写的那种Java代码就是面向对象编程。   说到这个面向对象哈，就要再来谈谈面向过程，咱们做个比较...
第3章 Java 主方法中的循环结构
qq_43514659的博客
05-13 3000
前言 嘿，同学，你今天学习了吗？ 你还在为了那些所谓的工作在忙碌吗？或者，沉迷在游戏的世界里面呢，总不能一直这样下去吧。 有时候呀，打开网易云音乐，然后在这里水水文章，刷刷题，也是一件很快乐的事情哦！冲冲冲 第一关：水仙花数 水仙花数特征： 该值处于 100（包括）到 999（包括）之间； 其个位数的三次幂，十位数的三次幂，百位数的三次幂的和等于这个数本身。 public class Test1 { public static void main(String[] args) { for(in
第2章 Java 主方法中的分支结构
qq_43514659的博客
05-12 2629
前言 本章目标是通过学习能够在 Java 的主方法中编写分支结构程序，涉及的 Java 编程基本概念包括：分支语句 if 、if-else、if-else if-else、switch 和 break 语句， 关系运算符、逻辑运算符和表达式，三目运算符 ? : 等。你准备好了吗？ 第一关：求三个数中最大者 public class Test1{ public static void main(String[] args) { Scanner input = new Scann
Java实战----- 随堂练习9
qq_43514659的博客
03-24 474
Java实战 编写管理员类 首先哈，我们搞个最简单的吧，就搞个账户和密码。 咳咳，对，这个类呢，就账户和密码两个属性。 方法呢，显示输出要吧，构造器要吧，然后就是题目要求的更改密码啦。 好的，确定后，就可以动手了。害，先上代码，先上代码。 package 随堂练习9; import java.util.Scanner; //提供输入类文件 public class Administrato...
Java Switch-Case 两例题解析与实现
资源摘要信息:"switch-java-switch-case-例题" 本资源主要涉及Java语言中的switch-case语句的使用，包含两个具体的例题。switch-case语句是Java中的一种控制流程语句，它根据变量的值选择性地执行对应的代码块，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

木木不会

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

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

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

打赏作者

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

抵扣说明：

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

余额充值