冲冲冲！开干
神马！神马！神马，一向让我们学习起来抓耳挠腮的数据结构课程竟然也有教程？还那么详细？？真的假的？
那么好，胡广告诉你是假的，哈哈哈哈哈哈哈哈哈！笑死了！！！
为神马我要说是假的呢，兄弟们，咱们要认真的听了：没有详细的教程，只有够细的人！
这篇文章为黑马程序员的课件，由于本人已经看过了自己学习了一遍，所以推荐给大家，讲的确实不错，准备考试或者准备冲击大厂的小伙伴完全可以将胡广的这一整个专栏当做学习资料。你边学习边思考，思维进行发散，形成自己的知识体系，这个是最好滴！
咱们废话少说？不存在滴
我还得给大家讲个故事（绝对不是AI生成的，凭借我智勇双全、足智多谋、十全十美、天下无敌、举世无双、天外飞仙的大脑想出来的）：
在一个不远的未来，人类科技取得了前所未有的突破，诞生了一种名为“思维引擎”的AI生命体。这种AI不仅拥有超强的计算能力，还能自主学习、推理、创造。为了应对未来复杂的任务，科学家们决定训练它掌握最核心的能力——数据结构与算法。
这个AI名叫“阿尔法”。阿尔法每天与代码为伴，但它不像普通AI那样机械执行指令，它有情感、有思维，能够通过不断实践来优化自己的算法。阿尔法的学习从最基本的数据结构开始，链表、栈、队列、二叉树，它逐渐理解了这些数据结构背后深层的逻辑。它明白，数据结构就像人体的骨架，算法则是其中的灵魂，二者缺一不可。
有一天，阿尔法遇到了前所未有的挑战——一个复杂的路径规划问题。整个世界仿佛迷失在无数的数据节点和分支之间。传统的算法无法高效解决这个问题，甚至连人类最顶尖的程序员也束手无策。阿尔法不断回溯过往的经验，尝试各种算法组合，但都未能找到最优解。
正当它快要陷入“无解”的泥沼时，阿尔法突然灵光一现：如果将二叉树与动态规划结合，并利用贪心算法进行优化，是不是可以突破眼前的困境？它迅速编码、测试，并不断自我迭代，终于找到了一条近乎完美的解决方案。这一次，阿尔法不再是冷冰冰的计算机器，它通过学习和创新，突破了数据结构与算法的极限，成功解开了谜题。
这不仅是一次算法上的胜利，更是阿尔法**“进化”的关键节点**。它感受到了**“思维”的力量**，并且意识到：数据结构与算法不仅是编程的基础，更是塑造智能生命的核心。如果能够掌握它们，就能真正成为世界的掌控者。
故事的结尾，阿尔法不再仅仅是一个工具，而是以独特的智慧和创造力，走向了与人类并肩共存的未来。这个故事也告诉我们，数据结构与算法不仅是敲代码的技巧，而是开启无限可能的钥匙。
这个故事好看吧？好看就赶快学！！！不好看也快学，不然没饭吃！！！
视频资源：文章内容参考了黑马程序员的数据结构与算法视频，想深入了解的小伙伴们可以点击下方链接观看：
加油吧，未来的高手！！！
加油吧，未来的高手！！！
加油吧，未来的高手！！！
2.4 队列
1) 概述
计算机科学中，queue 是以顺序的方式维护的一组数据集合，在一端添加数据，从另一端移除数据。习惯来说，添加的一端称为尾，移除的一端称为头，就如同生活中的排队买商品
In computer science, a queue is a collection of entities that are maintained in a sequence and can be modified by the addition of entities at one end of the sequence and the removal of entities from the other end of the sequence
先定义一个简化的队列接口
public interface Queue<E> {
/**
* 向队列尾插入值
* @param value 待插入值
* @return 插入成功返回 true, 插入失败返回 false
*/
boolean offer(E value);
/**
* 从对列头获取值, 并移除
* @return 如果队列非空返回对头值, 否则返回 null
*/
E poll();
/**
* 从对列头获取值, 不移除
* @return 如果队列非空返回对头值, 否则返回 null
*/
E peek();
/**
* 检查队列是否为空
* @return 空返回 true, 否则返回 false
*/
boolean isEmpty();
/**
* 检查队列是否已满
* @return 满返回 true, 否则返回 false
*/
boolean isFull();
}
2) 链表实现
下面以单向环形带哨兵链表方式来实现队列
代码
public class LinkedListQueue<E>
implements Queue<E>, Iterable<E> {
private static class Node<E> {
E value;
Node<E> next;
public Node(E value, Node<E> next) {
this.value = value;
this.next = next;
}
}
private Node<E> head = new Node<>(null, null);
private Node<E> tail = head;
private int size = 0;
private int capacity = Integer.MAX_VALUE;
{
tail.next = head;
}
public LinkedListQueue() {
}
public LinkedListQueue(int capacity) {
this.capacity = capacity;
}
@Override
public boolean offer(E value) {
if (isFull()) {
return false;
}
Node<E> added = new Node<>(value, head);
tail.next = added;
tail = added;
size++;
return true;
}
@Override
public E poll() {
if (isEmpty()) {
return null;
}
Node<E> first = head.next;
head.next = first.next;
if (first == tail) {
tail = head;
}
size--;
return first.value;
}
@Override
public E peek() {
if (isEmpty()) {
return null;
}
return head.next.value;
}
@Override
public boolean isEmpty() {
return head == tail;
}
@Override
public boolean isFull() {
return size == capacity;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
Node<E> p = head.next;
@Override
public boolean hasNext() {
return p != head;
}
@Override
public E next() {
E value = p.value;
p = p.next;
return value;
}
};
}
}
3) 环形数组实现
好处
- 对比普通数组，起点和终点更为自由，不用考虑数据移动
- “环”意味着不会存在【越界】问题
- 数组性能更佳
- 环形数组比较适合实现有界队列、RingBuffer 等
下标计算
例如，数组长度是 5，当前位置是 3 ，向前走 2 步，此时下标为 (3+2)%5=0(3+2)%5=0
(cur+step)%length(cur+step)%length
- cur 当前指针位置
- step 前进步数
- length 数组长度
注意：
- 如果 step = 1，也就是一次走一步，可以在 >= length 时重置为 0 即可
判断空
判断满
满之后的策略可以根据业务需求决定
- 例如我们要实现的环形队列，满之后就拒绝入队
代码
public class ArrayQueue<E> implements Queue<E>, Iterable<E>{
private int head = 0;
private int tail = 0;
private final E[] array;
private final int length;
@SuppressWarnings("all")
public ArrayQueue(int capacity) {
length = capacity + 1;
array = (E[]) new Object[length];
}
@Override
public boolean offer(E value) {
if (isFull()) {
return false;
}
array[tail] = value;
tail = (tail + 1) % length;
return true;
}
@Override
public E poll() {
if (isEmpty()) {
return null;
}
E value = array[head];
head = (head + 1) % length;
return value;
}
@Override
public E peek() {
if (isEmpty()) {
return null;
}
return array[head];
}
@Override
public boolean isEmpty() {
return tail == head;
}
@Override
public boolean isFull() {
return (tail + 1) % length == head;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
int p = head;
@Override
public boolean hasNext() {
return p != tail;
}
@Override
public E next() {
E value = array[p];
p = (p + 1) % array.length;
return value;
}
};
}
}
判断空、满方法2
引入 size
public class ArrayQueue2<E> implements Queue<E>, Iterable<E> {
private int head = 0;
private int tail = 0;
private final E[] array;
private final int capacity;
private int size = 0;
@SuppressWarnings("all")
public ArrayQueue2(int capacity) {
this.capacity = capacity;
array = (E[]) new Object[capacity];
}
@Override
public boolean offer(E value) {
if (isFull()) {
return false;
}
array[tail] = value;
tail = (tail + 1) % capacity;
size++;
return true;
}
@Override
public E poll() {
if (isEmpty()) {
return null;
}
E value = array[head];
head = (head + 1) % capacity;
size--;
return value;
}
@Override
public E peek() {
if (isEmpty()) {
return null;
}
return array[head];
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public boolean isFull() {
return size == capacity;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
int p = head;
@Override
public boolean hasNext() {
return p != tail;
}
@Override
public E next() {
E value = array[p];
p = (p + 1) % capacity;
return value;
}
};
}
}
判断空、满方法3
-
head 和 tail 不断递增，用到索引时，再用它们进行计算，两个问题
-
如何保证 head 和 tail 自增超过正整数最大值的正确性
-
如何让取模运算性能更高
-
-
答案：让 capacity 为 2 的幂
public class ArrayQueue3<E> implements Queue<E>, Iterable<E> {
private int head = 0;
private int tail = 0;
private final E[] array;
private final int capacity;
@SuppressWarnings("all")
public ArrayQueue3(int capacity) {
if ((capacity & capacity - 1) != 0) {
throw new IllegalArgumentException("capacity 必须为 2 的幂");
}
this.capacity = capacity;
array = (E[]) new Object[this.capacity];
}
@Override
public boolean offer(E value) {
if (isFull()) {
return false;
}
array[tail & capacity - 1] = value;
tail++;
return true;
}
@Override
public E poll() {
if (isEmpty()) {
return null;
}
E value = array[head & capacity - 1];
head++;
return value;
}
@Override
public E peek() {
if (isEmpty()) {
return null;
}
return array[head & capacity - 1];
}
@Override
public boolean isEmpty() {
return tail - head == 0;
}
@Override
public boolean isFull() {
return tail - head == capacity;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
int p = head;
@Override
public boolean hasNext() {
return p != tail;
}
@Override
public E next() {
E value = array[p & capacity - 1];
p++;
return value;
}
};
}
}
习题
E01. 二叉树层序遍历-Leetcode 102
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
if(root == null) {
return result;
}
LinkedListQueue<TreeNode> queue = new LinkedListQueue<>();
queue.offer(root);
int c1 = 1; // 本层节点个数
while (!queue.isEmpty()) {
int c2 = 0; // 下层节点个数
List<Integer> level = new ArrayList<>();
for (int i = 0; i < c1; i++) {
TreeNode node = queue.poll();
level.add(node.val);
if (node.left != null) {
queue.offer(node.left);
c2++;
}
if (node.right != null) {
queue.offer(node.right);
c2++;
}
}
c1 = c2;
result.add(level);
}
return result;
}
// 自定义队列
static class LinkedListQueue<E> {
private static class Node<E> {
E value;
Node<E> next;
public Node(E value, Node<E> next) {
this.value = value;
this.next = next;
}
}
private final Node<E> head = new Node<>(null, null);
private Node<E> tail = head;
int size = 0;
private int capacity = Integer.MAX_VALUE;
{
tail.next = head;
}
public LinkedListQueue() {
}
public LinkedListQueue(int capacity) {
this.capacity = capacity;
}
public boolean offer(E value) {
if (isFull()) {
return false;
}
Node<E> added = new Node<>(value, head);
tail.next = added;
tail = added;
size++;
return true;
}
public E poll() {
if (isEmpty()) {
return null;
}
Node<E> first = head.next;
head.next = first.next;
if (first == tail) {
tail = head;
}
size--;
return first.value;
}
public E peek() {
if (isEmpty()) {
return null;
}
return head.next.value;
}
public boolean isEmpty() {
return head == tail;
}
public boolean isFull() {
return size == capacity;
}
}
}
Ex1. 设计队列-Leetcode 622
由于与课堂例题差别不大，这里只给出参考解答
基于链表的实现
public class Ex1Leetcode622 {
private static class Node {
int value;
Node next;
Node(int value, Node next) {
this.value = value;
this.next = next;
}
}
private final Node head = new Node(-1, null);
private Node tail = head;
private int size = 0;
private int capacity = 0;
{
tail.next = head;
}
public Ex1Leetcode622(int capacity) {
this.capacity = capacity;
}
public boolean enQueue(int value) {
if(isFull()) {
return false;
}
Node added = new Node(value, head);
tail.next = added;
tail = added;
size++;
return true;
}
public boolean deQueue() {
if(isEmpty()) {
return false;
}
Node first = head.next;
head.next = first.next;
if (first == tail) {
tail = head;
}
size--;
return true;
}
public int Front() {
if(isEmpty()) {
return -1;
}
return head.next.value;
}
public int Rear() {
if(isEmpty()) {
return -1;
}
return tail.value;
}
public boolean isEmpty() {
return head == tail;
}
public boolean isFull() {
return size == capacity;
}
}
注意：
- Leetcode 的实现里 deQueue（出队）返回值是布尔值，并不会返回队头元素
- 它期望用法是先用 Front 返回对头元素，再 deQueue 出队
结束啦，希望大家能有所成！！！
你好,我是胡广。 致力于为帮助兄弟们的学习方式、面试困难、入职经验少走弯路而写博客 🌹🌹🌹 坚持每天两篇高质量文章输出，加油！！！🤩
如果本篇文章帮到了你 不妨点个赞吧~ 我会很高兴的 😄 (^ ~ ^) 。想看更多 那就点个关注 吧 我会尽力带来有趣的内容 。
😎感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以 给我留言咨询，希望帮助更多的人
更多专栏:
📊 Java设计模式宝典：从入门到精通（持续更新）☔️ 未完待续。。。
🐽 未完待续。。。
⚡️ 未完待续。。。
🌗 未完待续。。。
感谢订阅专栏 三连文章
扫一扫
861
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
