Java Deque队列讲解和案例示范

第一部分：Deque类概述

Deque的定义与特性

Deque（Double-Ended Queue）是一种双端队列，可以在两端高效地插入和删除元素。与Queue和Stack相比，Deque提供了更多的灵活性，因为它支持在两端进行操作。

• 特性：
  • 支持在队列的两端插入和删除元素。
  • 可以作为队列和栈的实现。
  • 可以存储null元素（在某些实现中）。

Deque与Queue和Stack的区别

• Queue：只允许在一端插入，在另一端删除，遵循先进先出（FIFO）原则。
• Stack：只允许在一端插入和删除，遵循后进先出（LIFO）原则。
• Deque：既可以在头部也可以在尾部插入和删除元素，提供了更多灵活性。

第二部分：Deque的常见方法讲解

Deque类提供了一系列常用方法来操作双端队列，以下是一些常见的方法及其示例：

1. 添加元素的方法

• addFirst(E e)：在队列的头部添加元素。
• addLast(E e)：在队列的尾部添加元素。

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("商品1");
deque.addLast("商品2");

2. 移除元素的方法

• removeFirst()：移除并返回队列的头元素。
• removeLast()：移除并返回队列的尾元素。

String first = deque.removeFirst(); // 返回"商品1"
String last = deque.removeLast();   // 返回"商品2"

3. 访问元素的方法

• getFirst()：获取队列的头元素但不移除。
• getLast()：获取队列的尾元素但不移除。

String head = deque.getFirst(); // 返回"商品1"
String tail = deque.getLast();   // 返回"商品2"

4. 迭代器的使用

Deque还支持迭代器的使用，可以遍历所有元素。

for (String item : deque) {
    System.out.println(item);
}

第三部分：Deque的使用示例

1. 购物车管理

购物车可以被视为一个Deque，用户可以随时添加、删除商品。

Deque<Product> cart = new ArrayDeque<>();
cart.addLast(new Product("商品1", 100));
cart.addLast(new Product("商品2", 200));
cart.removeFirst(); // 移除第一个商品

2. 浏览历史管理

用户在电商平台上的浏览历史可以使用Deque来管理，支持快速访问和删除。

Deque<Page> history = new ArrayDeque<>();
history.addLast(new Page("首页"));
history.addLast(new Page("商品详情"));
history.removeFirst(); // 删除最旧的页面

3. 订单处理

在订单处理系统中，Deque可以用于管理待处理订单。

Deque<Order> orders = new ArrayDeque<>();
orders.addLast(new Order(1, "用户1"));
orders.addLast(new Order(2, "用户2"));
Order nextOrder = orders.removeFirst(); // 处理下一个订单

第四部分：Deque的底层实现

Java中的Deque实现类

Java标准库提供了几个Deque的实现，主要包括：

1. ArrayDeque
   • 实现：基于动态数组，支持双端插入和删除。
   • 优点：相较于LinkedList，ArrayDeque在内存使用上更加高效，插入和删除操作通常更快。
   • 缺点：容量有限，当数组满时，需要进行扩容，扩容时会复制原数组，性能会受到影响。
2. LinkedList
   • 实现：基于链表，支持任意数量的元素。
   • 优点：支持动态扩展，插入和删除操作在链表的任意位置都很高效。
   • 缺点：每个元素都需要额外的内存存储指针，因此在内存使用上不如ArrayDeque高效。

ArrayDeque与LinkedList的比较

特性	ArrayDeque	LinkedList
内存使用	更少（动态数组）	更多（每个节点额外指针）
插入/删除操作复杂度	O(1)（平均情况下）	O(1)
随机访问复杂度	O(1)	O(n)
扩容	需要复制数组	动态扩展

内存使用与性能分析

• ArrayDeque：在大多数情况下，ArrayDeque由于内存连续，能够提供更好的缓存局部性，导致更快的访问速度。
• LinkedList：虽然支持动态大小，但由于内存的非连续性，频繁的内存分配和垃圾回收会影响性能。

第五部分：Deque与算法问题

Deque在解决某些经典算法问题时非常有用，以下是几个具体问题的示例：

1. 滑动窗口最大值问题

问题描述：给定一个整数数组和窗口大小k，找到每个滑动窗口的最大值。

代码示范：

import java.util.*;

public class SlidingWindowMax {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 0) return new int[0];
        int[] result = new int[nums.length - k + 1];
        Deque<Integer> deque = new ArrayDeque<>();

        for (int i = 0; i < nums.length; i++) {
            // 移除不在窗口中的元素
            if (!deque.isEmpty() && deque.peekFirst() == i - k) {
                deque.pollFirst();
            }
            // 移除比当前元素小的所有元素
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            deque.addLast(i);
            // 记录当前窗口的最大值
            if (i >= k - 1) {
                result[i - k + 1] = nums[deque.peekFirst()];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        SlidingWindowMax swm = new SlidingWindowMax();
        int[] nums = {1, 3, -1, -3, 5, 3, 6, 7};
        int k = 3;
        int[] result = swm.maxSlidingWindow(nums, k);
        System.out.println(Arrays.toString(result)); // 输出：[3, 3, 5, 5, 6, 7]
    }
}

2. 最小栈问题

问题描述：设计一个支持push、pop、top和retrieving the minimum element的栈。

代码示范：

class MinStack {
    private Deque<Integer> stack;
    private Deque<Integer> minStack;

    public MinStack() {
        stack = new ArrayDeque<>();
        minStack = new ArrayDeque<>();
    }

    public void push(int x) {
        stack.addLast(x);
        // 如果当前元素小于或等于最小元素，更新最小栈
        if (minStack.isEmpty() || x <= minStack.peekLast()) {
            minStack.addLast(x);
        }
    }

    public void pop() {
        int value = stack.removeLast();
        // 如果弹出的是当前最小元素，更新最小栈
        if (value == minStack.peekLast()) {
            minStack.removeLast();
        }
    }

    public int top() {
        return stack.peekLast();
    }

    public int getMin() {
        return minStack.peekLast();
    }

    public static void main(String[] args) {
        MinStack minStack = new MinStack();
        minStack.push(5);
        minStack.push(3);
        minStack.push(7);
        System.out.println(minStack.getMin()); // 输出：3
        minStack.pop();
        System.out.println(minStack.getMin()); // 输出：3
        minStack.pop();
        System.out.println(minStack.getMin()); // 输出：5
    }
}

复杂度分析

• 滑动窗口最大值问题：每个元素最多被添加和移除一次，因此时间复杂度为O(n)，空间复杂度为O(k)。
• 最小栈问题：所有操作的时间复杂度均为O(1)，空间复杂度为O(n)，因为存储了所有元素及其最小值。