java-数据结构与算法-02-数据结构-07-优先队列

最新推荐文章于 2024-09-07 21:56:33 发布
最新推荐文章于 2024-09-07 21:56:33 发布
阅读量1.7k 收藏 47
点赞数 49
分类专栏： Java-算法与数据结构 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gkqstd/article/details/140787783
版权

1. 概念

队列是一种先进先出的结构，但是有些时候，要操作的数据带有优先级，一般出队时，优先级较高的元素先出队，这种数据结构就叫做优先级队列。

比如：你在打音游的时候，你的朋友给你打了个电话，这种时候，就应该优先处理电话，然后再来继续打音游，此时，电话就是优先级较高的。

在这种情况下，数据结构应该提供两个最基本的操作，一个是返回优先级最高的对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)。

2. 无序数组实现

要点

  1. 入队保持顺序
  2. 出队前找到优先级最高的出队，相当于一次选择排序

队列实现类：

package com.itheima.datastructure.priorityqueue;

import com.itheima.datastructure.queue.Queue;

/**
 * 优先队列实现类，基于无序数组。
 * 使用无序数组实现优先队列，队列中的元素必须实现Priority接口，以提供优先级比较的方法。
 * 该实现类提供了标准的队列操作，包括入队、出队、查看队首元素、判断队列为空或满等。
 *
 * @param <E> 队列元素类型，必须实现Priority接口。
 */
@SuppressWarnings("all")
public class PriorityQueue1<E extends Priority> implements Queue<E> {

    // 存储队列元素的数组，元素类型为Priority接口的实现类。
    Priority[] array;
    // 当前队列的大小。
    int size;

    /**
     * 构造函数，初始化优先队列。
     * 
     * @param capacity 队列的容量，即最大元素数量。
     */
    public PriorityQueue1(int capacity) {
        array = new Priority[capacity];
    }

    /**
     * 入队操作，将元素添加到队列尾部。
     * 
     * @param e 待添加到队列的元素，必须实现Priority接口。
     * @return 添加成功返回true，队列已满返回false。
     */
    @Override // O(1)
    public boolean offer(E e) {
        if (isFull()) {
            return false;
        }
        array[size++] = e;
        return true;
    }

    /**
     * 查找优先级最高的元素的索引。
     * 
     * @return 优先级最高的元素的索引。
     */
    // 返回优先级最高的索引值
    private int selectMax() {
        int max = 0;
        for (int i = 1; i < size; i++) {
            if (array[i].priority() > array[max].priority()) {
                max = i;
            }
        }
        return max;
    }

    /**
     * 出队操作，移除并返回优先级最高的元素。
     * 
     * @return 被移除的优先级最高的元素，队列为空时返回null。
     */
    @Override // O(n)
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        int max = selectMax();
        E e = (E) array[max];
        remove(max);
        return e;
    }

    /**
     * 从数组中移除指定索引的元素，并将后续元素向前移动一位。
     * 
     * @param index 待移除元素的索引。
     */
    private void remove(int index) {
        if (index < size - 1) {
            // 移动
            System.arraycopy(array, index + 1,
                    array, index, size - 1 - index);
        }
        array[--size] = null; // help GC
    }

    /**
     * 查看队首元素，即优先级最高的元素，但不移除。
     * 
     * @return 队首元素，队列为空时返回null。
     */
    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        int max = selectMax();
        return (E) array[max];
    }

    /**
     * 判断队列是否为空。
     * 
     * @return 队列为空返回true，否则返回false。
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 判断队列是否已满。
     * 
     * @return 队列已满返回true，否则返回false。
     */
    @Override
    public boolean isFull() {
        return size == array.length;
    }
}

优先级类：

package com.itheima.datastructure.priorityqueue;

public interface Priority {

    /**
     * 返回对象的优先级, 约定数字越大, 优先级越高
     * @return 优先级
     */
    int priority();
}

条目类：

/**
 * 优先队列中的条目类，实现了Priority接口。
 * 该类用于存储具有特定优先级的值。
 */
package com.itheima.datastructure.priorityqueue;

class Entry implements Priority {

    String value; // 条目的值
    int priority; // 条目的优先级

    /**
     * 构造函数，创建一个具有指定优先级的条目。
     * @param priority 条目的优先级
     */
    public Entry(int priority) {
        this.priority = priority;
    }

    /**
     * 构造函数，创建一个具有指定值和优先级的条目。
     * @param value 条目的值
     * @param priority 条目的优先级
     */
    public Entry(String value, int priority) {
        this.value = value;
        this.priority = priority;
    }

    /**
     * 返回条目的优先级。
     * @return 条目的优先级
     */
    @Override
    public int priority() {
        return priority;
    }

    /**
     * 返回表示条目的字符串，格式为"(值 priority=优先级)"。
     * @return 表示条目的字符串
     */
    @Override
    public String toString() {
        return "(" + value + " priority=" + priority + ")";
    }

    /**
     * 比较当前对象与另一个对象是否相等。
     * 两个条目相等的定义是它们的优先级相同。
     * @param o 要比较的对象
     * @return 如果两个对象的优先级相同，则返回true；否则返回false。
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Entry entry = (Entry) o;

        return priority == entry.priority;
    }

    /**
     * 计算当前对象的哈希码，基于条目的优先级。
     * @return 当前对象的哈希码
     */
    @Override
    public int hashCode() {
        return priority;
    }
}

测试类：

package com.itheima.datastructure.priorityqueue;

import org.junit.jupiter.api.Test;

import java.util.Arrays;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

/*
    优先级队列       一端进, 另一端出       按优先级出队
    普通队列        一端进, 另一端出       FIFO
*/
public class TestPriorityQueue1 {

    @Test
    public void poll() {
        PriorityQueue1<Entry> queue = new PriorityQueue1<>(5);
        queue.offer(new Entry("task1", 4));
        queue.offer(new Entry("task2", 3));
        queue.offer(new Entry("task3", 2));
        queue.offer(new Entry("task4", 5));
        queue.offer(new Entry("task5", 1));
        assertFalse(queue.offer(new Entry("task6", 7)));

        System.out.println(Arrays.toString(queue.array));
        assertEquals(5, queue.poll().priority());
        System.out.println(Arrays.toString(queue.array));
        assertEquals(4, queue.poll().priority());
        assertEquals(3, queue.poll().priority());
        assertEquals(2, queue.poll().priority());
        assertEquals(1, queue.poll().priority());
    }
}

测试结果：

[(task1 priority=4), (task2 priority=3), (task3 priority=2), (task4 priority=5), (task5 priority=1)]
[(task1 priority=4), (task2 priority=3), (task3 priority=2), (task5 priority=1), null]

3. 有序数组实现

要点

  1. 入队后排好序，优先级最高的排列在尾部
  2. 出队只需删除尾部元素即可

队列实现类：

package com.itheima.datastructure.priorityqueue;

import com.itheima.datastructure.queue.Queue;

/**
 * 基于有序数组实现的优先队列。
 * 使用优先级高的元素先出（FIFO）的策略。
 *
 * @param <E> 队列中元素的类型，必须实现Priority接口以定义优先级。
 */
@SuppressWarnings("all")
public class PriorityQueue2<E extends Priority> implements Queue<E> {

    // 存储元素的数组，数组中的元素必须实现Priority接口
    Priority[] array;
    // 当前队列中元素的数量
    int size;

    /**
     * 构造函数，初始化优先队列。
     *
     * @param capacity 队列的容量，即最大元素数量。
     */
    public PriorityQueue2(int capacity) {
        array = new Priority[capacity];
    }

    /**
     * 向队列中添加一个元素。
     * 如果队列已满，则返回false。
     *
     * @param e 要添加到队列的元素，必须实现Priority接口。
     * @return 如果添加成功，返回true；否则返回false。
     */
    @Override
    public boolean offer(E e) {
        if (isFull()) {
            return false;
        }
        insert(e);
        size++;
        return true;
    }

    /**
     * 将元素插入到队列的正确位置，以保持队列的有序性。
     *
     * @param e 要插入的元素。
     */
    // O(n)
    private void insert(E e) {
        int i = size - 1;
        while (i >= 0 && array[i].priority() > e.priority()) {
            array[i + 1] = array[i];
            i--;
        }
        array[i + 1] = e;
    }

    /**
     * 从队列中移除并返回优先级最高的元素。
     * 如果队列为空，则返回null。
     *
     * @return 被移除的元素，如果队列为空，则返回null。
     */
    // O(1)
    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E e = (E) array[size - 1];
        array[--size] = null; // help GC
        return e;
    }

    /**
     * 返回优先级最高的元素，但不移除它。
     * 如果队列为空，则返回null。
     *
     * @return 队列头部的元素，如果队列为空，则返回null。
     */
    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E) array[size - 1];
    }

    /**
     * 检查队列是否为空。
     *
     * @return 如果队列为空，返回true；否则返回false。
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 检查队列是否已满。
     *
     * @return 如果队列已满，返回true；否则返回false。
     */
    @Override
    public boolean isFull() {
        return size == array.length;
    }
}

测试类：

package com.itheima.datastructure.priorityqueue;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

public class TestPriorityQueue2 {

    @Test
    public void poll() {
        PriorityQueue2<Entry> queue = new PriorityQueue2<>(5);
        queue.offer(new Entry("task1", 4));
        queue.offer(new Entry("task2", 3));
        queue.offer(new Entry("task3", 2));
        queue.offer(new Entry("task4", 5));
        queue.offer(new Entry("task5", 1));
        assertFalse(queue.offer(new Entry("task6", 7)));

        assertEquals("task4", queue.peek().value);
        assertEquals("task4", queue.poll().value);
        assertEquals("task1", queue.poll().value);
        assertEquals("task2", queue.poll().value);
        assertEquals("task3", queue.poll().value);
        assertEquals("task5", queue.poll().value);
    }
}

4. 堆实现

JDK1.8中的 PriorityQueue 底层使用了堆这种数据结构，而堆实际就是在完全二叉树的基础上进行了一些调整。也就是说，堆的是由完全二叉树调整而来的，可以存储到数组中。

堆的概念
如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为 小堆(或 大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的性质：

  • 堆中某个节点的值总是不大于或不小于其父节点的值。
  • 堆总是一棵完全二叉树。
    如图：
    在这里插入图片描述
    在这里插入图片描述

计算机科学中，堆是一种基于树的数据结构，通常用完全二叉树实现。堆的特性如下

  • 在大顶堆中，任意节点 C 与它的父节点 P 符合 P . v a l u e ≥ C . v a l u e P.value \geq C.value P.value≥C.value
  • 而小顶堆中，任意节点 C 与它的父节点 P 符合 P . v a l u e ≤ C . v a l u e P.value \leq C.value P.value≤C.value
  • 最顶层的节点（没有父亲）称之为 root 根节点

完全二叉树可以使用数组来表示

在这里插入图片描述
特征

● 如果从索引 0 开始存储节点数据
○ 节点 i i i 的父节点为 f l o o r ( ( i − 1 ) / 2 ) floor((i-1)/2) floor((i−1)/2)，当 i > 0 i>0 i>0 时
○ 节点 i i i 的左子节点为 2 i + 1 2i+1 2i+1，右子节点为 2 i + 2 2i+2 2i+2，当然它们得 < s i z e < size <size
● 如果从索引 1 开始存储节点数据
○ 节点 i i i 的父节点为 f l o o r ( i / 2 ) floor(i/2) floor(i/2)，当 i > 1 i > 1 i>1 时
○ 节点 i i i 的左子节点为 2 i 2i 2i，右子节点为 2 i + 1 2i+1 2i+1，同样得 < s i z e < size <size

实现类：

package com.itheima.datastructure.priorityqueue;

import com.itheima.datastructure.queue.Queue;

/**
 * 基于大顶堆实现的优先队列。
 * 大顶堆是一个完全二叉树，每个父节点的优先级不小于其子节点的优先级。
 * @param <E> 队列中元素的类型，必须实现Priority接口以定义元素的优先级。
 */
@SuppressWarnings("all")
public class PriorityQueue4<E extends Priority> implements Queue<E> {

    Priority[] array; // 存储优先队列元素的数组
    int size; // 当前队列的大小

    /**
     * 构造函数，初始化优先队列。
     * @param capacity 队列的初始容量。
     */
    public PriorityQueue4(int capacity) {
        array = new Priority[capacity];
    }

    /**
     * 向队列中添加一个元素。
     * 如果队列已满，则返回false；否则将元素加入队列，并调整堆以保持大顶堆的性质。
     * @param offered 要添加到队列的元素。
     * @return 如果添加成功，返回true；如果队列已满，返回false。
     */
    /*
    1. 入堆新元素, 加入到数组末尾 (索引位置 child)
    2. 不断比较新加元素与它父节点(parent)优先级 (上浮)
        - 如果父节点优先级低, 则向下移动, 并找到下一个 parent
        - 直至父节点优先级更高或 child==0 为止
     */
    @Override
    public boolean offer(E offered) {
        // 检查队列是否已满，如果已满，则拒绝添加新元素并返回false。
        if (isFull()) {
            return false;
        }
        // 将新元素插入到数组的末尾，并记录其位置。
        int child = size++;
        // 计算新元素的父节点位置。
        int parent = (child - 1) / 2;
        // 上浮新元素，直到它位于正确的位置或者它是根元素。
        while (child > 0 && offered.priority() > array[parent].priority()) {
            // 将当前元素的父元素移动到当前元素的位置，准备继续上浮。
            array[child] = array[parent];
            child = parent;
            // 更新当前元素的父节点位置。
            parent = (child - 1) / 2;
        }
        // 将新元素放置在最终的位置上，完成添加。
        array[child] = offered;
        // 添加成功，返回true。
        return true;
    }

    /**
     * 从队列中移除并返回优先级最高的元素（即堆顶元素）。
     * 如果队列为空，则返回null。
     * @return 优先级最高的元素，如果队列为空，则返回null。
     */
    /*
    1. 交换堆顶和尾部元素, 让尾部元素出队
    2. (下潜)
        - 从堆顶开始, 将父元素与两个孩子较大者交换
        - 直到父元素大于两个孩子, 或没有孩子为止
     */
    @Override
    public E poll() {
        // 检查队列是否为空，如果为空则返回null
        if (isEmpty()) {
            return null;
        }
        // 交换堆顶元素（优先级最高）和队列尾部元素，准备移除堆顶元素
        swap(0, size - 1);
        // 更新队列大小，表示已移除一个元素
        size--;
        // 获取并保存即将返回的堆顶元素
        Priority e = array[size];
        // 将队列尾部元素置为null，帮助垃圾回收
        array[size] = null; // help GC

        // 调整堆结构，确保堆的性质依然满足
        // 下潜
        down(0);

        // 返回移除的堆顶元素
        return (E) e;
    }

    /**
     * 将元素向下调整以保持大顶堆的性质。
     * 此方法假设调用时堆已经部分有序，它通过比较父节点和其子节点的优先级来确保整个堆仍然满足大顶堆的定义。
     * 如果父节点的优先级低于某个子节点，则交换它们，并继续向下调整子节点，直到整个子树满足大顶堆的条件。
     *
     * @param parent 需要向下调整的父节点的索引。
     */
    /**
     * 将元素向下调整以保持大顶堆的性质。
     * @param parent 需要向下调整的元素的索引。
     */
    private void down(int parent) {
        // 计算左子节点和右子节点的索引
        int left = 2 * parent + 1;
        int right = left + 1;

        // 假设当前父节点的优先级最高
        int max = parent; // 假设父元素优先级最高

        // 如果左子节点存在且优先级高于当前最大值，则更新最大值索引
        if (left < size && array[left].priority() > array[max].priority()) {
            max = left;
        }

        // 如果右子节点存在且优先级高于当前最大值，则更新最大值索引
        if (right < size && array[right].priority() > array[max].priority()) {
            max = right;
        }

        // 如果最大值不是初始的父节点，则交换它们，并递归向下调整新父节点
        if (max != parent) { // 有孩子比父亲大
            swap(max, parent);
            down(max);
        }
    }

    /**
     * 交换数组中两个元素的位置。
     * @param i 第一个元素的索引。
     * @param j 第二个元素的索引。
     */
    private void swap(int i, int j) {
        Priority t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

    /**
     * 返回队列中优先级最高的元素（即堆顶元素），但不移除它。
     * 如果队列为空，则返回null。
     * @return 优先级最高的元素，如果队列为空，则返回null。
     */
    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E) array[0];
    }

    /**
     * 检查队列是否为空。
     * @return 如果队列为空，返回true；否则返回false。
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 检查队列是否已满。
     * @return 如果队列已满，返回true；否则返回false。
     */
    @Override
    public boolean isFull() {
        return size == array.length;
    }
}

5. 习题

E01. 合并多个有序链表-Leetcode 23

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]
示例 3：

输入：lists = [[]]
输出：[]

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

这道题目之前解答过，现在用刚学的优先级队列来实现一下
题目中要从小到大排列，因此选择用小顶堆来实现，思路如下图：
在这里插入图片描述

自定义小顶堆如下

package com.itheima.datastructure.priorityqueue;

import com.itheima.datastructure.linkedlist.ListNode;

/**
 * 小顶堆类，实现优先队列功能。
 * 小顶堆是一个完全二叉树，每个父节点的值都小于或等于其子节点的值。
 */
/**
 * <b>小顶堆</b>
 */
public class MinHeap {

    /**
     * 堆数组，存储堆中的节点。
     */
    ListNode[] array;
    /**
     * 堆的当前大小，即堆中节点的数量。
     */
    int size;

    /**
     * 构造函数，初始化小顶堆。
     *
     * @param capacity 堆的容量，即堆数组的大小。
     */
    public MinHeap(int capacity) {
        array = new ListNode[capacity];
    }

    /**
     * 将一个节点添加到最小堆中。
     * 如果堆已满，则拒绝添加，并返回false；否则，将节点添加到堆中并维护堆的性质。
     *
     * @param offered 要添加到堆中的节点。
     * @return 如果成功添加节点，则返回true；如果堆已满，则返回false。
     */
    /**
     * 向堆中插入一个节点。
     *
     * @param offered 要插入的节点。
     * @return 如果堆已满，返回false；否则返回true。
     */
    public boolean offer(ListNode offered) {
        // 检查堆是否已满，如果已满则无法添加新节点
        if (isFull()) {
            return false;
        }
        // 将新节点插入到堆的最后一个位置，并更新堆的大小
        int child = size++;
        // 计算新节点的父节点位置
        int parent = (child - 1) / 2;
        // 当节点不在根位置且小于其父节点时，向上调整节点位置以维护最小堆性质
        while (child > 0 && offered.val < array[parent].val) {
            // 将父节点值复制到当前节点
            array[child] = array[parent];
            // 更新当前节点为父节点，并计算新的父节点位置
            child = parent;
            parent = (child - 1) / 2;
        }
        // 将新节点值插入到最终位置，完成添加
        array[child] = offered;
        return true;
    }


    /**
     * 从堆中移除并返回最小的节点。
     *
     * @return 如果堆为空，返回null；否则返回移除的最小节点。
     */
    public ListNode poll() {
        if (isEmpty()) {
            return null;
        }
        swap(0, size - 1);
        size--;
        ListNode e = array[size];
        array[size] = null; // help GC

        // 下潜
        down(0);

        return e;
    }

    /**
     * 将堆中指定元素下沉以维护堆的性质。
     * 这个方法是堆排序或优先队列操作中的关键部分，它确保堆的性质得以维持。
     * 当插入一个新元素或某个元素的值被更新后，可能需要调用此方法来重新调整堆。
     *
     * @param parent 要下沉的元素的索引，该元素是其子节点的父节点。
     */
    private void down(int parent) {
        // 计算左子节点和右子节点的索引
        int left = 2 * parent + 1;
        int right = left + 1;
        // 假设当前父节点是最小的
        // 如果左子节点存在且值小于当前最小值，则更新最小值为左子节点
        int min = parent; // 假设父元素最小
        if (left < size && array[left].val < array[min].val) {
            min = left;
        }
        // 如果右子节点存在且值小于当前最小值，则更新最小值为右子节点
        if (right < size && array[right].val < array[min].val) {
            min = right;
        }
        // 如果找到的最小值不是初始的父节点，则交换它们并继续下沉最小值节点
        if (min != parent) { // 有孩子比父亲小
            swap(min, parent);
            down(min);
        }
    }


    /**
     * 交换堆数组中两个节点的位置。
     *
     * @param i 第一个节点的索引。
     * @param j 第二个节点的索引。
     */
    private void swap(int i, int j) {
        ListNode t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

    /**
     * 检查堆是否为空。
     *
     * @return 如果堆为空，返回true；否则返回false。
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 检查堆是否已满。
     *
     * @return 如果堆已满，返回true；否则返回false。
     */
    public boolean isFull() {
        return size == array.length;
    }
}

代码

package com.itheima.datastructure.priorityqueue;

import com.itheima.datastructure.linkedlist.ListNode;

/**
 * 合并多个有序链表的工具类。
 */
public class E01Leetcode23 {
    
    /**
     * 使用最小堆合并多个有序链表。
     * 
     * @param lists 多个有序链表的数组形式。
     * @return 合并后的单个有序链表。
     */
    public ListNode mergeKLists2(ListNode[] lists) {
        MinHeap heap = new MinHeap(100);
        // 将所有链表的节点加入最小堆
        // 1. 将链表的所有节点加入小顶堆
        for (ListNode p : lists) {
            while (p != null) {
                heap.offer(p);
                p = p.next;
            }
        }
        // 从最小堆中依次取出节点构建合并后的链表
        // 2. 不断从堆顶移除最小元素, 加入新链表
        ListNode s = new ListNode(-1, null);
        ListNode t = s;
        while(!heap.isEmpty()) {
            ListNode min = heap.poll();
            t.next = min;
            t = min;
            t.next = null; // 保证尾部节点指向 null
        }
        return s.next;
    }

    /**
     * 使用最小堆合并多个有序链表的另一种实现方式。
     * 
     * @param lists 多个有序链表的数组形式。
     * @return 合并后的单个有序链表。
     */
    public ListNode mergeKLists(ListNode[] lists) {
        MinHeap heap = new MinHeap(lists.length);
        // 将所有链表的头节点加入最小堆
        // 1. 将链表的头节点加入小顶堆
        for (ListNode h : lists) {
            if(h != null) {
                heap.offer(h);
            }
        }
        // 从最小堆中依次取出节点构建合并后的链表
        // 2. 不断从堆顶移除最小元素, 加入新链表
        ListNode s = new ListNode(-1, null);
        ListNode t = s;
        while(!heap.isEmpty()) {
            ListNode min = heap.poll();
            t.next = min;
            t = min;
            // 将当前节点的下一个节点加入最小堆
            // 将最小元素的下一个节点加入到堆
            if(min.next != null) {
                heap.offer(min.next);
            }
        }
        return s.next;
    }

    /**
     * 测试合并多个有序链表的函数。
     * 
     * @param args 命令行参数。
     */
    public static void main(String[] args) {
        ListNode[] lists = {
                ListNode.of(1, 4, 5),
                ListNode.of(1, 3, 4),
                ListNode.of(2, 6),
                null,
        };
        ListNode m = new E01Leetcode23().mergeKLists2(lists);
        System.out.println(m);
    }
}
被拯救的威尼斯
关注
  • 49
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DataStructure-尚硅谷-数据结构与算法-数据结构.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
极客时间-数据结构与算法-王争.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
hello-algo-数据结构与算法-zh-csharp.pdf
01-24
本书的内容涵盖了数据结构与算法的基础知识，包括数组、链表、栈、队列、树、图等数据结构，以及排序、查找、图形遍历等算法。书中还提供了大量的编程实践和习题，帮助读者更好地掌握数据结构与算法的知识。 本书的...
JAVA---算法与数据结构
04-08
在"JAVA---算法与数据结构"这个主题中，我们将深入探讨Java中常用的数据结构，如数组、链表、栈、队列、集合、映射、树（二叉树、红黑树）和图等。每种数据结构都有其独特的优势和适用场景，例如，数组适合随机访问...
structure-project(java数据结构与算法).zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 539
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1280
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 689
SpringBoot 项目集成 xxl-job
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1025
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
weixin_53180424的博客
09-03 970
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
自定义Stater
m0_63624484的博客
09-07 483
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 826
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
数据访问：JPA
hhgh_的博客
09-02 1025
其二，Sun希望整合ORM 技术，实现统一的 API调用接口。@Table（name=“”,catalog=“”,schema=“”）可选，用来标注一个数据库对应的实体类，数据库中创建的表明默认和类名一致，通常和@Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息。@Entity(name=“EntityName”)必须，用来标注一个数据库表对应的实体，数据库中创建的表明默认和类名一致，其中，name可选，对应数据库中的一个表，使用此注解标记Pojo是一个JPA实体。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
最新发布
不起眼小菜菜的博客
09-07 113
步骤很详细，直接上教程……
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 522
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 1001
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
java后端开发-Mybatis连接数据库步骤
weixin_73355603的博客
09-02 1949
🎙座右铭：得之坦然，失之淡然。💎擅长领域：前端是的，我需要您的：是我持续下去的动力！先看看目录，是不是IDEA的配置，数据库mysql或者其他的数据库这套方法都适合的。
SpringBoot总结
2302_77073236的博客
09-06 124
都做成图了，方便理解和掌握全局关系。
基于SpringBoot的多媒体信息共享平台开发
qq_45800365的博客
09-06 150
基于SpringBoot的多媒体信息共享平台开发,java项目。eclipse和idea都能打开运行。推荐环境配置：eclipse/idea jdk1.8 maven mysql前端技术：vue，Ajax，Json后端技术：SpringBoot，MyBatis本系统共分为两个角色：管理员和用户。主要功能有:后台：系统首页个人中心用户管理作品分类管理作品信息管理私聊信息管理系统管理前台：首页作品信息公告信息后台管理个人中心。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值