数据结构与算法 - 双端队列

已于 2024-08-25 10:52:57 修改
阅读量705 收藏 16
点赞数 19
分类专栏： 数据结构与算法 文章标签： 双端队列 deque 数据结构
于 2024-08-03 11:42:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ltt159264/article/details/140885742
版权

1. 概述

双端队列、队列、栈对比

定义特点
队列一端删除（头），另一端添加（尾）First In First Out
栈一端删除和添加（顶）Last In First Out
双端队列两端都可以删除、添加
优先级队列优先级高者先出队
延时队列根据延时时间确定优先级
并发非阻塞队列队列空或满时不阻塞
并发阻塞队列队列空时删除阻塞、队列满时添加阻塞

注1：Java中LinkedList即为典型双端队列实现，不过它同时实现了Queue接口，也提供了栈的push、pop等方法。

注2：不同语言，操作双端队列的方法命名有所不同，参见下表

操作JavaJavaScriptC++LeetCode 641
尾部插入offerLastpushpush_backinsertLast
头部插入offerFirstunshiftpush_frontinsertFront
尾部移除pollLastpoppop_backdeleteLast
头部移除pollFirstshiftpop_frontdeleteFront
尾部获取peekLastat(-1)backgetRear
头部获取peekFirstat(0)frontgetFront


接口定义

package com.itheima.datastructure.deque;

/**
 * 双端队列接口
 * @param <E> 队列中元素类型
 */
public interface Deque<E> {

    boolean offerFirst(E e);

    boolean offerLast(E e);

    E pollFirst();

    E pollLast();

    E peekFirst();

    E peekLast();

    boolean isEmpty();

    boolean isFull();
}

2. 基于双向环形链表实现

package com.itheima.datastructure.Deque;

import java.util.Iterator;

public class LinkedListDeque<E> implements Deque<E>, Iterable<E> {
    static class Node<E> {
        Node<E> prev;
        E value;
        Node<E> next;

        public Node(Node<E> prev, E value, Node<E> next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }

    int capacity;
    int size;
    Node<E> sentinel = new Node<>(null,null, null);

    public LinkedListDeque(int capacity) {
        this.capacity = capacity;
        sentinel.next = sentinel;
        sentinel.prev = sentinel;
    }

    @Override
    public boolean offerFirst(E e) {
        if(isFull()) {
            return false;
        }
        // 处理4个指针
        Node<E> a = sentinel;
        Node<E> b = sentinel.next;
        Node<E> added = new Node<>(a, e, b);
        a.next = added;
        b.prev = added;
        size++;
        return true;
    }

    // a added b
    @Override
    public boolean offerLast(E e) {
        if(isFull()) {
            return false;
        }

        Node<E> b = sentinel;
        Node<E> a = sentinel.prev;
        Node<E> added = new Node<>(a, e, b);
        a.next = added;
        b.prev = added;
        size++;
        return true;
    }

    @Override
    public E pollFirst() {
        if(isEmpty()) {
            return null;
        }

        Node<E> a = sentinel;
        Node<E> removed = sentinel.next;
        Node<E> b = sentinel.next.next;
        a.next = b;
        b.prev = a;
        size--;
        return removed.value;
    }

    @Override
    public E pollLast() {
        if(isEmpty()) {
            return null;
        }

        Node<E> a = sentinel.prev.prev;
        Node<E> removed = sentinel.prev;
        Node<E> b = sentinel;
        a.next = b;
        b.prev = a;
        size--;
        return removed.value;
    }

    @Override
    public E peekFirst() {
        if(isEmpty()) {
            return null;
        }
        return sentinel.next.value;
    }

    @Override
    public E peekLast() {
        if(isEmpty()) {
            return null;
        }

        return sentinel.prev.value;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == capacity;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            Node<E> p = sentinel.next;
            @Override
            public boolean hasNext() {
                return p != sentinel;
            }

            @Override
            public E next() {
                E value = p.value;
                p = p.next;
                return value;
            }
        };
    }
}

3. 基于循环数组实现

package com.itheima.datastructure.Deque;

import java.util.Iterator;

public class ArrayDeque1<E> implements Deque<E>, Iterable<E>{
    E[] array;
    int head;
    int tail;

    public ArrayDeque1(int capacity) {
        array = (E[]) new Object[capacity + 1];  // 留一个空位置
    }
    
    static int inc(int i, int length) {
        if(i + 1 >= length) {
            return 0;
        }
        return i + 1;
    }
    
    static int dec(int i, int length) {
        if(i - 1 < 0) {
            return length - 1;
        }
        return i - 1;
    }

    @Override
    public boolean offerFirst(E e) {
        if(isFull()) {
            return false;
        }
        // head先往前一个位置，再存放元素
        head = dec(head, array.length);
        array[head] = e;
        return true;
    }

    @Override
    public boolean offerLast(E e) {
        if(isFull()) {
            return false;
        }
        // 先存放元素到tail所在位置，再将tail往后一个位置
        array[tail] = e;
        tail = inc(tail, array.length);
        return true;
    }

    @Override
    public E pollFirst() {
        if(isEmpty()) {
            return null;
        }
        // 先获取head位置的元素，然后将其置空，并将head往后移一个位置
        E e = array[head];
        array[head] = null;
        head = inc(head, array.length);
        return e;
    }

    @Override
    public E pollLast() {
        if(isEmpty()) {
            return null;
        }
        // 先将tail的位置往前移一位，获取tail位置的元素并将其置空
        tail = dec(tail, array.length);
        E e = array[tail];
        array[tail] = null;
        return e;
    }

    @Override
    public E peekFirst() {
        if(isEmpty()) {
            return null;
        }
        return array[head];
    }

    @Override
    public E peekLast() {
        if(isEmpty()) {
            return null;
        }
        return array[tail - 1];
    }

    @Override
    public boolean isEmpty() {
        return head == tail;
    }

    @Override
    public boolean isFull() {
        if(tail > head) {
            return tail - head == array.length - 1;
        } else if(tail < head) {
            return head - tail == 1;
        } else {
            return false;
        }
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public E next() {
                E e = array[p];
                p = inc(p, array.length);
                return e;
            }
        };
    }
}

4. 习题

4.1 二叉树Z字层序遍历

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -100 <= Node.val <= 100

解法一：双端队列 + 二叉树层序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root); // 根节点入队
        boolean odd = true;  // 判断是否是奇数行
        int c1 = 1;  // 当前层的结点数

        while (!queue.isEmpty()) {
            int c2 = 0;
            LinkedList<Integer> deque = new LinkedList<>();  // 存储当前层
            for (int i = 0; i < c1; i++) {
                TreeNode n = queue.poll();
                if (odd) {  // 奇数行，从左往右
                    deque.offerLast(n.val);  // 尾插
                } else {  // 偶数行，从右往左
                    deque.offerFirst(n.val);  // 头插
                }

                if (n.left != null) {
                    queue.offer(n.left);
                    c2++;
                }
                if (n.right != null) {
                    queue.offer(n.right);
                    c2++;
                }
            }
            c1 = c2;
            odd = !odd;
            result.add(deque);
        }
        return result;
    }
}

4.2 设计双端循环队列

设计实现双端队列。

实现 MyCircularDeque 类:

  • MyCircularDeque(int k) ：构造函数,双端队列最大为 k 。
  • boolean insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true ，否则返回 false 。
  • boolean insertLast() ：将一个元素添加到双端队列尾部。如果操作成功返回 true ，否则返回 false 。
  • boolean deleteFront() ：从双端队列头部删除一个元素。 如果操作成功返回 true ，否则返回 false 。
  • boolean deleteLast() ：从双端队列尾部删除一个元素。如果操作成功返回 true ，否则返回 false 。
  • int getFront() )：从双端队列头部获得一个元素。如果双端队列为空，返回 -1 。
  • int getRear() ：获得双端队列的最后一个元素。 如果双端队列为空，返回 -1 。
  • boolean isEmpty() ：若双端队列为空，则返回 true ，否则返回 false  。
  • boolean isFull() ：若双端队列满了，则返回 true ，否则返回 false 。

示例 1：

输入
["MyCircularDeque", "insertLast", "insertLast", "insertFront", "insertFront", "getRear", "isFull", "deleteLast", "insertFront", "getFront"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
输出
[null, true, true, true, false, 2, true, true, true, 4]

解释
MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3
circularDeque.insertLast(1);			        // 返回 true
circularDeque.insertLast(2);			        // 返回 true
circularDeque.insertFront(3);			        // 返回 true
circularDeque.insertFront(4);			        // 已经满了，返回 false
circularDeque.getRear();  				// 返回 2
circularDeque.isFull();				        // 返回 true
circularDeque.deleteLast();			        // 返回 true
circularDeque.insertFront(4);			        // 返回 true
circularDeque.getFront();				// 返回 4

提示：

  • 1 <= k <= 1000
  • 0 <= value <= 1000
  • insertFront, insertLast, deleteFront, deleteLast, getFront, getRear, isEmpty, isFull  调用次数不大于 2000 次
class MyCircularDeque {  
    static class Node {  
        Node prev;  
        int value;  
        Node next;  

        public Node(Node prev, int value, Node next) {  
            this.prev = prev;  
            this.value = value;  
            this.next = next;  
        }  
    }  

    int capacity;  
    int size = 0;  
    Node sentinel;  

    public MyCircularDeque(int k) {  
        this.capacity = k;  
        sentinel = new Node(null, 0, null); // Node中应该有一个默认值，这里使用0  
        sentinel.next = sentinel;  
        sentinel.prev = sentinel;  
    }  
    
    public boolean insertFront(int value) {  
        if (isFull()) {  
            return false;  
        }  
        Node added = new Node(sentinel, value, sentinel.next);  
        sentinel.next.prev = added;  
        sentinel.next = added;  
        size++;  
        return true;  
    }  
    
    public boolean insertLast(int value) {  
        if (isFull()) {  
            return false;  
        }  
        Node added = new Node(sentinel.prev, value, sentinel);  
        sentinel.prev.next = added;  
        sentinel.prev = added;  
        size++;  
        return true;  
    }  
    
    public boolean deleteFront() {  
        if (isEmpty()) {  
            return false; // 应该返回 false，而不是 null  
        }  
        Node front = sentinel.next;  
        sentinel.next = front.next;  
        front.next.prev = sentinel;  
        size--;  
        return true;  
    }  
    
    public boolean deleteLast() {  
        if (isEmpty()) {  
            return false; // 应该返回 false，而不是 null  
        }  
        Node rear = sentinel.prev;  
        sentinel.prev = rear.prev;  
        rear.prev.next = sentinel;  
        size--;  
        return true;  
    }  
    
    public int getFront() {  
        if (isEmpty()) {  
            return -1; // 返回-1表示队列为空  
        }  
        return sentinel.next.value;  
    }  
    
    public int getRear() {  
        if (isEmpty()) {  
            return -1; // 返回-1表示队列为空  
        }  
        return sentinel.prev.value;  
    }  
    
    public boolean isEmpty() {  
        return size == 0;  
    }  
    
    public boolean isFull() {  
        return size == capacity;  
    }  
}  

/**  
 * Your MyCircularDeque object will be instantiated and called as such:  
 * MyCircularDeque obj = new MyCircularDeque(k);  
 * boolean param_1 = obj.insertFront(value);  
 * boolean param_2 = obj.insertLast(value);  
 * boolean param_3 = obj.deleteFront();  
 * boolean param_4 = obj.deleteLast();  
 * int param_5 = obj.getFront();  
 * int param_6 = obj.getRear();  
 * boolean param_7 = obj.isEmpty();  
 * boolean param_8 = obj.isFull();  
 */

临界点oc
关注
专栏目录
Python数据结构与算法（4）---双端队列deque
李元静
05-11 3593
目录前言 前言
【数据结构与算法】双端队列 deque
weixin_46062098的博客
05-25 368
参考《程序员面试指南：IT名企算法于数据结构题目最优解（第2版）》 双端队列deque 普通的队列是先入先出FIFO（First In First Out），只能从队尾添加元素，从队首弹出元素。而双端队列则是从队尾添加元素，但是既可以从队首弹出元素，和普通的队列一样，也可以和栈一样从队尾弹出元素，所以叫双端队列deque（double-ended queue），它同时具备队列（FIFO）和栈（LIFO）的特性。 生成窗口最大值数组 题目描述 有一个整型数组arr和一个大小为w的窗口从数组的最左边滑到最右边
队列与双端队列的实现
Demon_LMMan的博客
02-19 502
队列 队列是一种特殊的线性表，只能在头尾两端进行操作 队尾（rear）：只能从队尾添加元素，一般叫做 enQueue，入队 队头（front）：只能从队头移除元素，一般叫做 deQueue，出队 先进先出的原则，First In First Out，FIFO java官网的Queue是一个接口，具体实现是双向链表LinkedList 示意图 队列的接口设计 方法声明 功能介绍 int size() 元素的数量 boolean isEmpty() 是否为空 void clear(
双端队列
salmonwilliam的博客
04-05 242
rotate：队列右移
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
算法-数据结构和算法-5-队列和双端队列.rar
09-16
在计算机科学领域，数据结构和算法是至关重要的...通过阅读“数据结构和算法-5-队列和双端队列.pdf”这份文档，你可以深入学习它们的实现细节、操作方法以及在实际问题中的应用，从而在编程实践中更好地运用这些工具。
双端队列 C 实现
you-know-who的博客
03-31 4629
双端队列可以前插后插前删后删，通过数组实现，这里给出基本功能： 头文件如下：#ifndef _Double_Queue_H #define _Double_Queue_H struct PtrToNode; typedef struct PtrToNode *double_Queue; typedef int Item; double_Queue initial(void); int isE
双端队列的使用
Every Master was once a disaster or beginner.
03-28 1082
蒜头君学习完数据结构之后，发现这种普通的栈已经不能满足自己的需求了。于是蒜头君想自己手动写一个超级栈。超级栈和普通栈不同的是，如果自己想往栈底添加数据的话，可以通过把栈翻转，然后再往栈顶添加数据来完成。听起来是不是觉得这个栈很厉害？对于超级栈的操作有四种：(1) 11 表示把栈反转(2) 22 表示把栈顶元素出栈(3) 3 \ x3 x 表示把 xx 放到栈顶(4) 44 表示把栈内所有的元素从栈...
数据结构(队列):双端队列
acesfre的博客
04-17 1192
/* *数据结构(队列):双端队列 *用单链表实现,链式存储结构 *Date:2017/4/16 */ #include #include #define ElemType char #define InitSize 100 typedef struct LNode{ ElemType data; struct LNode *next; }LNode; typedef stru
数据结构_队列_双端队列
weixin_37841366的博客
09-19 783
队列（Queue） 特点：和栈不同，队列的最大特点是先进先出（FIFO），就好像按顺序排队一样。对于队列的数据来说，我们只允许在队尾查看和添加数据，在队头查看和删除数据。 实现：可以借助双链表来实现队列。双链表的头指针允许在队头查看和删除数据，而双链表的尾指针允许我们在队尾查看和添加数据。 应用场景：直观来看，当我们需要按照一定的顺序来处理数据，而该数据的数据量在不断地变化的时候，则需要队列来帮助解题。在算法面试题当中，广度优先搜索（Breadth-First Search）是运用队列最多的地方，我们将
队列——双端队列
最新发布
time_silence的博客
01-26 423
双端队列
数据结构与算法解析：栈、队列与双端队列
双端队列（Deque）则更灵活，允许在两端进行插入和删除操作，适用于需要同时在头部和尾部操作数据的场景。 栈与递归有着密切的关系。在递归调用中，每次函数调用都会将相关信息压入栈中，形成调用栈，直到遇到基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值