【数据结构】关于Java对象比较，以及优先级队列的大小堆创建你了解多少？？？

GGBondlctrl

于 2024-08-19 17:43:49 发布

阅读量1.5k

点赞数 44

分类专栏：数据结构文章标签：数据结构对象的比较优先级队列大小堆优先级队列对象插入 topK问题

本文链接：https://blog.csdn.net/ggbond778/article/details/141322285

版权

数据结构专栏收录该内容

19 篇文章 0 订阅

订阅专栏

前言：

🌟🌟Hello家人们，这期讲解对象的比较，以及优先级队列堆，希望你能帮到屏幕前的你。

🌈上期博客在这里：http://t.csdnimg.cn/MSex7

🌈感兴趣的小伙伴看一看小编主页：GGBondlctrl-CSDN博客

📚️1. PriorityQueue中插入对象

📚️4.PriorityQueue的比较方式

4.1PriorityQueue的比较

4.2PriorityQueue大小堆解决topK问题

📚️总结

📚️1. PriorityQueue中插入对象

上期博客讲了优先级队列，优先级队列在插入元素时有个要求：插入的元素不能是null或者元素之间必须要能够进行比较，为了简单起见，我们只是插入了Integer类型，那优先级队列中能否插入自定义类型对象呢？

代码如下：

class Card {
   public int rank; // 数值
   public String suit; // 花色
   public Card(int rank, String suit) {
      this.rank = rank;
      this.suit = suit;
   }
}

public class TestPriorityQueue {
    public static void TestPriorityQueue()
    {
        PriorityQueue<Card> p = new PriorityQueue<>();
        p.offer(new Card(1, "♠"));
        p.offer(new Card(2, "♠"));
    }
    public static void main(String[] args) {
         TestPriorityQueue();
    }
}

那么此时我们运行时就会抛出异常：

因为放置的元素必须要能够比较大小，不能插入无法比较大小的对象。在这里，小编给Card类初始化了它的大小，和花色使得在编译时，不知道该比较那个。

📚️2元素的比较

2.1基本类型的比较

在Java中基本数据类型可以直接进行比较，一般通过>,<或者==来进行判断，放回值为boolean类型，小编这里就不再过多解释，相信大家因该了解了。

2.2对象比较问题

1.通过比较运算符

代码如下：

        Student student=new Student(12,"zhangsan");
        Student student1=new Student(12,"zhangsan");
        
        System.out.println(student1==student);

此时输出的值为false；

因为在“==”在实质上是比较的两个对象的地址，很明显这两个同学并不是同一个地址的，他们两个都new了一个地址出来，所以该地输出为false。

2.通过equals比较

代码如下：

        Student student=new Student(12,"zhangsan");
        Student student1=new Student(12,"zhangsan");
        System.out.println(student1.equals(student));

此时输出为false；

在这里，我们可以通过内部原理进行解析：

对于用户实现自定义类型，都默认继承自Object类，而Object类中提供了equal方法，而==默认情况下调用的就是equal方法，但是该方法的比较规则是：没有比较引用变量引用对象的内容，而是直接比较引用变量的地址

内部原理代码如下：

在这里this为student1,因为是student1调用函数与另一个学生进行比较，此时student就为obj。那么结果到头来还是地址的比较，所以还是为不等false 。

📚️3.对象的比较

3.1重写基类的equals方法

代码如下：

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

    @Override                         //进行重写
    public boolean equals(Object o) {
        if (this == o) return true;
        if(o==null||!(o instanceof Student)){
            return false;
        }
        Student student=(Student) o;
        return age==student.age&&name==student.name;
    }
}

在这里第一个条件：如果是自己调用自己那么就一定相等

在这里第二个条件：如果括号里的对象是空的，或者不是student的子类，那么就不相等

在这里最后的情况：实现强转，并且通过调用其年龄，和名字进行比较，并返回，实现equals重写

覆写基类equal的方式虽然可以比较，但缺陷是：equal只能按照相等进行比较，不能按照大于、小于的方式进行比较

3.2基于Comparble接口类的比较

对用用户自定义类型，如果要想按照大小与方式进行比较时：在定义类时，实现Comparble接口即可，然后在类中重写compareTo方法。

代码如下：

class Card implements Comparable<Card>{
    public int rank;
    public String suit;
    public Card(int rank,String suit) {
        this.rank=rank;
        this.suit=suit;
    }
    public int compareTo(Card o){
        return rank-o.rank;
    }
}
public class test {
    public static void main(String[] args) {
       

        Card card=new Card(5,"♥");
        Card card1=new Card(5,"♥");
        System.out.println(card.compareTo(card1));
    }
}

在重写compareTo方法时，是通过两者的大小进行比较，返回如果是一个正数，那么前者比后者更大，反之如果为一个负数那么就是后者更大，为0那么表示两者相同。

3.3基于比较器进行比较

用户自定义比较器类，实现Comparator接口，并且重写Comparator中的compare方法

代码如下：

class Agecompare implements Comparator<Student>{
    public int compare(Student s1,Student s2){
        return s1.age-s2.age;
    }
}
class Namecompare implements Comparator<Student>{
    public int compare(Student s1,Student s2){
        return s1.name.compareTo(s2.name);
    }
}
public class test {
    public static void main(String[] args) {
       

        Agecompare agecompare=new Agecompare();
        Namecompare namecompare=new Namecompare();
       
        Student student2=new Student(12,"lisi");
        Student student3=new Student(12,"lisi");
        System.out.println(agecompare.compare(student2,student3));
        System.out.println(namecompare.compare(student2,student3));

       
    }
}

这里要单独定义类来实现接口，并且重写接口当中的方法，在进行比较时对定义的类进行实例化，并且通过对应对象调用重写的compare方法，然后传递参数即可。

注意：但是在用对像调用时，名字为string类不能够相减，此时string引用类型compareto方法进行比较。因为string实现了comparable接口，重写了compareto方法。

3.4三种比较方式

覆写的方法：
Object.equals

因为所有类都是继承自 Object 的，所以直接覆写即可，不过只能比较相等与否
Comparable.compareTo
需要手动实现接口，侵入性比较强，但一旦实现，每次用该类都有顺序，属于内部顺序
Comparator.compare
需要实现一个比较器对象，对待比较类的侵入性弱，但对算法代码实现侵入性强

📚️4.PriorityQueue的比较方式

4.1PriorityQueue的比较

当我们实现了compareor接口，并且重写了内部方法后，在PriorityQueue中如何实现添加对象呢？

代码如下：

class Agecompare implements Comparator<Student>{
    public int compare(Student s1,Student s2){
        return s1.age-s2.age;
    }
}
public class test {
    public static void main(String[] args) {
       
        Agecompare agecompare=new Agecompare();
       
        PriorityQueue<Student> p=new PriorityQueue<>(agecompare);
        p.offer(student);
        p.offer(student1);
        System.out.println(p.peek());
        p.poll();
        System.out.println(p.peek());
        
    }
}

此时我们需要实例化实现接口的类，并将比较器的实例作为参数传入，此时就能够传入学生对象了，但是输出是学生对象的地址，并没有实际意义。

4.2PriorityQueue大小堆解决topK问题

大小堆的接口实现：

class MaxHeap implements Comparator<Integer>{  //创建大堆
    public int compare(Integer o1,Integer o2){
        return o2-o1;
    }
}
class MinHeap implements Comparator<Integer>{  //创建小堆
    public int compare(Integer o1,Integer o2){
        return o1-o2;
    }
}

思路：在需要输出前K个最小的数目时，我们要创建大根堆，前k个数字组成的大根堆，当后面数字与堆顶元素比较时（堆顶元素最大）如果小于堆顶元素，那么就删除堆顶元素，将更小的元素传入堆中，那么在遍历完数组后，前K个组成的堆中就是最小的元素。

代码如下：

class MintTopK {
    public void mink(int[] array,int k){
        if(k<=0){
            return;
        }
        MaxHeap maxHeap=new MaxHeap();
        PriorityQueue<Integer> q=new PriorityQueue<>(maxHeap);

        //创建一个大根堆（前k个值）
        for (int i = 0; i < k; i++) {
            q.offer(array[i]);
        }

        //堆剩下的数据进行操作
        for (int i = k; i < array.length ; i++) {
            if(array[i]<q.peek()){
                q.poll();
                q.offer(array[i]);
            }
        }

        //开始输出前k个数
        for (int i = 0; i <k ; i++) {
            int ret=q.poll();
            System.out.print(ret+" ");
        }
    }
}


public class test {
    public static void main(String[] args) {
       
        int[] array={1,4,3,2,9};
        MintTopK mintTopK=new MintTopK();
        mintTopK.mink(array,3);
    }
}

那么此时的输出就为3 2 1；