堆的基础功能实现和优先级队列

2023-12-16 03:50:04

1. 堆的插入与删除

1.1 堆的插入

????????步骤:

? ? ? ? 1、先将元素放入到底层空间中(注意:一般是放到整个二叉树的最后一个叶子节点的后边,其次存储空间不够时需要扩容)

? ? ? ? 2、将最后新插入的节点向上调整,直到满足堆的性质(判断该节点所在的小二叉树根节点域该节点的关系是否满足该二叉树的性质),详细插入图解分析如下图所示:

? ? ? ? 堆的插入代码如下图所示:

?

public void shiftUp(int child,int[] array) {
            // 找到child的双亲
            int parent = (child - 1) / 2;
            while (child > 0) {
                // 如果双亲比孩子大,parent满足堆的性质,调整结束
                if (array[parent] > array[child]) {
                    break;
                }
                else{
                // 将双亲与孩子节点进行交换
                    int t = array[parent];
                    array[parent] = array[child];
                    array[child] = t;
                // 小的元素向下移动,可能到值子树不满足对的性质,因此需要继续向上调增
                    child = parent;
                    parent = (child - 1) / 1;
                }
            }
        }

1.2 堆的删除

????????思路:堆的删除a一定删除的是堆顶元素。具体分析如下:

? ? ? ? 1、将堆顶元素a与堆中最后一个元素z交换

? ? ? ? 2、将堆中有效数据个数减少一个(此时堆中的最后一个元素a被优化)

? ? ? ? 3、对堆顶元素进行向下调整,其中删除图解如下图所示;

1.3 堆的常见习题?

?eg1.下列关键字序列为堆的是:()

????????A: 100,60,70,50,32,65

????????B: 60,70,65,50,32,100

????????C: 65,100,70,32,50,60

????????D: 70,65,100,32,50,60

????????E: 32,50,100,70,65,60

????????F: 50,100,70,65,60,32

由选项画图可知,只有a选项满足堆的基本性质;

eg2.已知小根堆为8,15,10,21,34,16,12,删除关键字8之后需重建堆,在此过程中,关键字之间的比较次数是()

A: 1???????? B: 2???????? C: 3???????? D: 4

分析如下:

1、该小根堆如下图所示:

2、删除8后(将末尾节点12与根节点8交换,并删除尾节点)

2.1 首先确定根节点

? ? ? ? 15和10节点比较--->12与10进行比较

2.2 根节点的右叶子结点

? ? ? ? 12节点与16

由此可得,一共比较三次;

eg3.最小堆[0,3,2,5,7,4,6,8],在删除堆顶元素0之后,其结果是()

A: [3,2,5,7,4,6,8]

B: [2,3,5,7,4,6,8]

C: [2,3,4,5,7,8,6]

D: [2,3,4,5,6,7,8]

题解如下分析:

1、原题小根堆如下图所示:

删除堆顶元素0后为

按步骤向下调整

故此,答案选c

?2. 优先级队列(PriorityQueue)

2.1 PriorityQueue的特性

????????Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列,PriorityQueue是线程不安全的,PriorityBlockingQueue是线程安全的(主要是在多线程案例中,为了在定时器案例中保证多个线程在针对一个对象的应用中让代码按照我们的预期效果执行,而引入的),本文主要介绍PriorityQueue。优先级队列与其他接口的实现关系如下图所示:

? ? ? ? ? ? ? ? ? ? ? ? ? ??

????????关于PriorityQueue的使用要注意:

1. 使用时必须导入PriorityQueue所在的包,即:

2. PriorityQueue中放置的元素必须要能够比较大小,不能插入无法比较大小的对象,否则会抛出 ClassCastException异常

3. 不能插入null对象,否则会抛出NullPointerException

4. 没有容量限制,可以插入任意多个元素,其内部可以自动扩容

5. 插入和删除元素的时间复杂度为o(log 2 n)

6. PriorityQueue底层使用了堆数据结构

7. PriorityQueue默认情况下是小堆---即每次获取到的元素都是最小的元素

?2.2 PriorityQueue常用接口介绍

2.2.1 优先级队列的构造

? ? ? ? 如下图所示,只是列出了PriorityQueue中常见的几种构造方式即相应的所实现的功能。

static void TestPriorityQueue(){
// 创建一个空的优先级队列,底层默认容量是11
        PriorityQueue<Integer> q1 = new PriorityQueue<>();
// 创建一个空的优先级队列,底层的容量为initialCapacity
        PriorityQueue<Integer> q2 = new PriorityQueue<>(100);
        ArrayList<Integer> list = new ArrayList<>();
        list.add(4);
        list.add(3);
        list.add(2);
        list.add(1);
// 用ArrayList对象来构造一个优先级队列的对象
// q3中已经包含了三个元素
        PriorityQueue<Integer> q3 = new PriorityQueue<>(list);
        System.out.println(q3.size());
        System.out.println(q3.peek());
    }

?????????注意:默认情况下,PriorityQueue队列是小堆,如果需要大堆需要用户提供比较器

import java.util.Comparator;
import java.util.PriorityQueue;

// 用户自己定义的比较器:直接实现Comparator接口,然后重写该接口中的compare方法即可
class IntCmp implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
}
public class TestPriorityQueue {
    public static void main(String[] args) {
        PriorityQueue<Integer> p = new PriorityQueue<>(new IntCmp());
        p.offer(4);
        p.offer(3);
        p.offer(2);
        p.offer(1);
        p.offer(5);
        System.out.println(p.peek());
    }
}

2.2.2 插入/删除/获取优先级最高的元素

? ? ? ? 如下图所示是相应方法的展示及功能介绍:

? ? ? ? ? ??

? ? ? ? ?相应代码功能实现如下图所示:

    static void TestPriorityQueue2(){
        int[] arr = {4,1,9,2,8,0,7,3,6,5};
// 一般在创建优先级队列对象时,如果知道元素个数,建议就直接将底层容量给好
// 否则在插入时需要不多的扩容
// 扩容机制:开辟更大的空间,拷贝元素,这样效率会比较低
        PriorityQueue<Integer> q = new PriorityQueue<>(arr.length);
        for (int e: arr) {
            q.offer(e);
        }
        System.out.println(q.size()); // 打印优先级队列中有效元素个数
        System.out.println(q.peek()); // 获取优先级最高的元素
// 从优先级队列中删除两个元素之和,再次获取优先级最高的元素
        q.poll();
        q.poll();
        System.out.println(q.size()); // 打印优先级队列中有效元素个数
        System.out.println(q.peek()); // 获取优先级最高的元素
        q.offer(0);
        System.out.println(q.peek()); // 获取优先级最高的元素
// 将优先级队列中的有效元素删除掉,检测其是否为空
        q.clear();
        if(q.isEmpty()){
            System.out.println("优先级队列已经为空!!!");
        } else {
            System.out.println("优先级队列不为空");
        }
    }

?2.2.3 PriorityQueue的扩容方式

????????注意:以下是JDK 1.8中,PriorityQueue的扩容方式:

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
        int oldCapacity = queue.length;
// Double size if small; else grow by 50%
        int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                (oldCapacity + 2) :
                (oldCapacity >> 1));
// overflow-conscious code
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        queue = Arrays.copyOf(queue, newCapacity);
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

?优先级队列的扩容说明(上述代码小结):

  • 如果容量小于64时,是按照oldCapacity的2倍方式扩容的

  • 如果容量大于等于64,是按照oldCapacity的1.5倍方式扩容的

  • 如果容量超过MAX_ARRAY_SIZE,按照MAX_ARRAY_SIZE来进行扩容

3. 堆的应用

????????PriorityQueue的实现:用堆作为底层结构封装优先级队列?

3.1 堆排序

????????堆排序即利用堆的思想来进行排序,总共分为两个步骤:

1. 建堆

????????升序:建大堆

????????降序:建小堆

2. 利用堆删除思想来进行排序 建堆和堆删除中都用到了向下调整,因此掌握了向下调整,就可以完成堆排序,其中过程详解如下图所示:

4. 关于java对象的比较?

4.1 基于Comparble接口类的比较

Comparble是JDK提供的泛型的比较接口类,源码实现具体如下:

public interface Comparable<E> {
    // 返回值:
    // < 0: 表示 this 指向的对象小于 o 指向的对象
    // == 0: 表示 this 指向的对象等于 o 指向的对象
    // > 0: 表示 this 指向的对象大于 o 指向的对象
    int compareTo(E o);
}

?????????对与用户所使用的自定义类型,如果要想按照大小与方式进行比较时:在定义类时,实现Comparble接口即可,然后在类中重写compareTo方法,例如以下代码:

public class Card implements Comparable<Card> {
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
    // 根据数值比较,不管花色
    // 这里我们认为 null 是最小的
    @Override
    public int compareTo(Card o) {
        if (o == null) {
            return 1;
        }
        return rank - o.rank;
    }
    public static void main(String[] args){
        Card p = new Card(1, "?");
        Card q = new Card(2, "?");
        Card o = new Card(1, "?");
        System.out.println(p.compareTo(o)); // == 0,表示牌相等
        System.out.println(p.compareTo(q)); // < 0,表示 p 比较小
        System.out.println(q.compareTo(p)); // > 0,表示 q 比较大
    }
}

4.2 基于比较器比较?

按照比较器方式进行比较,具体步骤如下:

  • 用户自定义比较器类,实现Comparator接口
public interface Comparator<T> {
    // 返回值:
// < 0: 表示 o1 指向的对象小于 o2 指向的对象
// == 0: 表示 o1 指向的对象等于 o2 指向的对象
// > 0: 表示 o1 指向的对象等于 o2 指向的对象
    int compare(T o1, T o2);
}
  • 覆写Comparator中的compare方法,代码如下(注意:Comparator是java.util 包中的泛型接口类,使用时必须导入对应的包):
import java.util.Comparator;
class Card {
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
}
public class CardComparator implements Comparator<Card> {
    
    // 根据数值比较,不管花色
// 这里我们认为 null 是最小的
    @Override
    public int compare(Card o1, Card o2) {
        if (o1 == o2) {
            return 0;
        } if
        (o1 == null) {
            return -1;
        }
        if (o2 == null) {
            return 1;
        } 
        return o1.rank - o2.rank;
    }
    public static void main(String[] args){
        Card p = new Card(1, "?");
        Card q = new Card(2, "?");
        Card o = new Card(1, "?");
// 定义比较器对象
        CardComparator cmptor = new CardComparator();
// 使用比较器对象进行比较
        System.out.println(cmptor.compare(p, o)); // == 0,表示牌相等
        System.out.println(cmptor.compare(p, q)); // < 0,表示 p 比较小
        System.out.println(cmptor.compare(q, p)); // > 0,表示 q 比较大
    }
}

4.3 三种方式对比?

4.4集合框架中PriorityQueue的比较方式

????????集合框架中的PriorityQueue底层使用堆结构,因此其内部的元素必须要能够比大小,PriorityQueue采用了:Comparble和Comparator两种方式。

????????Comparble是默认的内部比较方式,如果用户插入自定义类型对象时,该类对象必须要实现Comparble接口,并覆写compareTo方法

? ? ? ? 同时也可以选择使用比较器对象,如果用户插入自定义类型对象时,必须要提供一个比较器类,让该类实现Comparator接口并覆写compare方法。

// JDK中PriorityQueue的实现:
public class PriorityQueue<E> extends AbstractQueue<E>
        implements java.io.Serializable {
    // ...
    // 默认容量
    private static final int DEFAULT_INITIAL_CAPACITY = 11;
    // 内部定义的比较器对象,用来接收用户实例化PriorityQueue对象时提供的比较器对象
    private final Comparator<? super E> comparator;
    // 用户如果没有提供比较器对象,使用默认的内部比较,将comparator置为null
    public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    } 
    // 如果用户提供了比较器,采用用户提供的比较器进行比较
    public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
    // Note: This restriction of at least one is not actually needed,
    // but continues for 1.5 compatibility
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity];
        this.comparator = comparator;
    } 
    // ...
    // 向上调整:
    // 如果用户没有提供比较器对象,采用Comparable进行比较
    // 否则使用用户提供的比较器对象进行比较
    private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }
    // 使用Comparable
    @SuppressWarnings("unchecked")
    private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
    } 
    // 使用用户提供的比较器对象进行比较
    @SuppressWarnings("unchecked")
    private void siftUpUsingComparator(int k, E x) {
        }while (k > 0) {
        int parent = (k - 1) >>> 1;
        Object e = queue[parent];
        if (comparator.compare(x, (E) e) >= 0)
            break;
        queue[k] = e;
        k = parent;
    }
    queue[k] = x;
}

ps:本次的学习就到这里了,喜欢的话还请大家一键三连哦!!1?

?

?

文章来源:https://blog.csdn.net/2202_76101487/article/details/134914608
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。