Java基础编程500题——LinkedList和PriorityQueue

 💥 该系列属于【Java基础编程500题】专栏，如您需查看Java基础的其他相关题目，请您点击左边的连接

目录

1. 反转LinkedList。

2. 编写一个方法，该方法接受一个LinkedList作为参数，并找到并打印出中间元素。

3. 编写一个程序，使用LinkedList实现队列的基本操作：入队、出队和查看队首元素。

4. 使用LinkedList作为队列，出队所有元素并打印。

5. 使用PriorityQueue，并从中删除最小元素。

6. 使用PriorityQueue实现最大堆，并添加一些整数到堆中。

7. 使用PriorityQueue，合并两个最小堆。

8. 使用PriorityQueue，并定义一个自定义排序规则，例如按照字符串长度排序。

9. 使用PriorityQueue，并定义一个自定义排序规则，例如按照字符串长度排序，例如按照字符长度升序排序。

10. 使用PriorityQueue，并删除堆中特定的元素。

11. 使用PriorityQueue找出一系列整数中的前N个最大元素。

12. 使用PriorityQueue实现一个简单的任务调度器，任务按照优先级排序。

---

✨✨  返回题目目录 ✨ ✨ 

Java基础编程500题

---

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 + ")");
        }
    }


}