Java基础编程500题——LinkedList和PriorityQueue
💥 该系列属于【Java基础编程500题】专栏，如您需查看Java基础的其他相关题目，请您点击左边的连接
目录
2. 编写一个方法，该方法接受一个LinkedList作为参数，并找到并打印出中间元素。
3. 编写一个程序，使用LinkedList实现队列的基本操作：入队、出队和查看队首元素。
4. 使用LinkedList作为队列，出队所有元素并打印。
6. 使用PriorityQueue实现最大堆，并添加一些整数到堆中。
8. 使用PriorityQueue，并定义一个自定义排序规则，例如按照字符串长度排序。
9. 使用PriorityQueue，并定义一个自定义排序规则，例如按照字符串长度排序，例如按照字符长度升序排序。
10. 使用PriorityQueue，并删除堆中特定的元素。
11. 使用PriorityQueue找出一系列整数中的前N个最大元素。
12. 使用PriorityQueue实现一个简单的任务调度器，任务按照优先级排序。
✨✨ 返回题目目录 ✨ ✨
1. 反转LinkedList。
import java.util.LinkedList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println("原始链表：" + list);
Collections.reverse(list);
System.out.println("反转后的链表：" + list);
}
}
2. 编写一个方法，该方法接受一个LinkedList作为参数，并找到并打印出中间元素。
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println("链表：" + list);
findMiddleElement(list);
}
private static void findMiddleElement(LinkedList<Integer> list) {
int middle = list.size() / 2;
System.out.println("中间元素：" + list.get(middle));
}
}
3. 编写一个程序，使用LinkedList实现队列的基本操作：入队、出队和查看队首元素。
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<Integer> queue = new LinkedList<>();
// 入队
queue.offer(1);
queue.offer(2);
queue.offer(3);
System.out.println("入队后的队列：" + queue);
// 查看队首元素
System.out.println("队首元素：" + queue.peek());
// 出队
System.out.println("出队元素：" + queue.poll());
System.out.println("出队后的队列：" + queue);
}
}
4. 使用LinkedList作为队列，出队所有元素并打印。
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<Integer> queue = new LinkedList<>();
// 入队元素
queue.offer(1);
queue.offer(2);
queue.offer(3);
queue.offer(4);
queue.offer(5);
System.out.println("队列元素：" + queue);
// 出队并打印
while (!queue.isEmpty()) {
System.out.println("出队元素：" + queue.poll());
}
}
}
5. 使用PriorityQueue，并从中删除最小元素。
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
// 添加元素
minHeap.offer(5);
minHeap.offer(3);
minHeap.offer(8);
minHeap.add(1);
minHeap.add(2);
System.out.println("删除前最小堆中的元素：" + minHeap);
System.out.println("删除的最小元素：" + minHeap.poll());
System.out.println("删除后最小堆中的元素：" + minHeap);
}
}
6. 使用PriorityQueue实现最大堆，并添加一些整数到堆中。
import java.util.PriorityQueue;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
// 添加元素
maxHeap.add(5);
maxHeap.add(3);
maxHeap.add(8);
maxHeap.add(1);
maxHeap.add(2);
System.out.println("最大堆中的元素：" + maxHeap); //最大堆中的元素：[8, 3, 5, 1, 2]
}
}
7. 使用PriorityQueue，合并两个最小堆。
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> minHeap1 = new PriorityQueue<>();
PriorityQueue<Integer> minHeap2 = new PriorityQueue<>();
// 添加元素到第一个最小堆
minHeap1.add(5);
minHeap1.add(3);
minHeap1.add(1);
// 添加元素到第二个最小堆
minHeap2.add(8);
minHeap2.add(2);
minHeap2.add(4);
// 合并两个最小堆
PriorityQueue<Integer> mergedHeap = new PriorityQueue<>(minHeap1);
mergedHeap.addAll(minHeap2);
System.out.println("合并后的最小堆中的元素：" + mergedHeap);
}
}
8. 使用PriorityQueue，并定义一个自定义排序规则，例如按照字符串长度排序。
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<String> queue = new PriorityQueue<>((s1, s2) -> s1.length() - s2.length());
// 添加元素
queue.add("苹果");
queue.add("香蕉");
queue.add("橙子");
queue.add("西瓜");
System.out.println("按字符串长度排序的元素：" + queue);
}
}
9. 使用PriorityQueue，并定义一个自定义排序规则，例如按照字符串长度排序，例如按照字符长度升序排序。
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<String> queue = new PriorityQueue<>((s1, s2) -> s1.length() - s2.length());
// 添加元素
queue.add("apple");
queue.add("banana");
queue.add("orange");
queue.add("watermelon");
System.out.println("按字符串长度排序的元素：" + queue);
}
}
10. 使用PriorityQueue，并删除堆中特定的元素。
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
// 添加元素
minHeap.add(5);
minHeap.add(3);
minHeap.add(8);
minHeap.add(1);
minHeap.add(2);
System.out.println("删除前最小堆中的元素：" + minHeap);
// 删除特定元素
minHeap.remove(3);
System.out.println("删除元素3后的最小堆：" + minHeap);
}
}
11. 使用PriorityQueue找出一系列整数中的前N个最大元素。
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
int[] numbers = {5, 3, 8, 1, 2, 7, 6, 4};
int n = 3;
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
// 添加元素到最小堆
for (int number : numbers) {
minHeap.add(number);
if (minHeap.size() > n) {
minHeap.poll();
}
}
System.out.println("数组中的前" + n + "个最大元素：" + minHeap);
}
}
12. 使用PriorityQueue实现一个简单的任务调度器，任务按照优先级排序。
import java.util.PriorityQueue;
class Task {
String name;
int priority;
Task(String name, int priority) {
this.name = name;
this.priority = priority;
}
}
public class Main {
public static void main(String[] args) {
PriorityQueue<Task> taskQueue = new PriorityQueue<>((t1, t2) -> t2.priority - t1.priority);
// 添加任务
taskQueue.add(new Task("任务1", 3));
taskQueue.add(new Task("任务2", 1));
taskQueue.add(new Task("任务3", 2));
System.out.println("任务调度顺序：");
while (!taskQueue.isEmpty()) {
Task task = taskQueue.poll();
System.out.println(task.name + " (优先级：" + task.priority + ")");
}
}
}
原文地址：https://blog.csdn.net/m0_53140426/article/details/140576592
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！