CS61B:循环队列

最新推荐文章于 2024-10-05 15:48:11 发布
最新推荐文章于 2024-10-05 15:48:11 发布
阅读量1.2k 收藏 25
点赞数 33
分类专栏： 算法与数据结构 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52010229/article/details/138258968
版权

循环队列

  • 本循环队列使用顺序表与双向链表实现循环队列。
  • 使用junit测试完所有类的方法。
  • 使用泛型使得循环队列可以容纳任意元素。

循环顺序表

数据结构：
在这里插入图片描述

实现方法：

  • public ArrayDeque() 初始化ArrayDeque队列，将nextLast,nextFirst,itemFirst都设置为相同值。
  • public void resize(int capacity) 根据capacity调整队列大小，并将所有元素从itemFirst到最后一个元素移动到新的队列，并更新nextLast，nextFirst，itemFirst的位置信息。
  • public void addFirst(T item)在队列的头部添加新的元素，对于size为0特殊处理。
  • public void addLast(T item)在队列的尾部添加新的元素，对size为0特殊处理。
  • public boolean isEmpty() 判断队列是否为空，为空返回true。
  • public int size()返回当前队列的大小，通过成员变量size避免迭代。
  • public void printDeque()打印当前对列中的所有元素，元素间用空格分隔，输出完毕后，输出回车。
  • public T removeFirst()删除当前队列头部元素，当队列的使用率小于等于0.25时，调整队列大小，当size为0特殊处理。
  • public T removeLast()删除当前队列尾部元素，当队列的使用率小于等于0.25时，调整队列大小，当size为0特殊处理。
  • public T get(int index)获取当前队列index上的元素，由于队列的头部不确定，所以通过循环查找元素位置。
public class ArrayDeque<T> {
    private T[] items;
    private int size;
    private int RFACTOR = 2;
    private int itemFirst;
    private int nextFirst;
    private int nextLast;
    public ArrayDeque() {
        items = (T[]) new Object[8];
        size = 0;
        nextLast = 0;
        nextFirst = 0;
        itemFirst = 0;
    }

    public void resize(int capacity) {
        T[] a = (T[]) new Object[capacity];
        int index = itemFirst;
        for (int i = 0; i < size; i++) {
            a[i] = items[index];
            index = (index + 1) % items.length;
        }
        itemFirst = 0;
        nextFirst = capacity - 1;
        nextLast = size;
        items = a;
    }

    /**
     * Adds an item of type T to the front of the deque.
     * @param item
     */
    public void addFirst(T item) {
        if (size >= items.length) {
            resize(size * RFACTOR);
        }
        if (size == 0) {
            items[itemFirst] = item;
            nextFirst = (itemFirst - 1 + items.length) % items.length;
            nextLast = (itemFirst + 1) % items.length;
            size++;
            return;
        }
        items[nextFirst] = item;
        nextFirst = (nextFirst - 1 + items.length) % items.length;
        itemFirst = (itemFirst - 1 + items.length) % items.length;
        size++;
    }

    /**
     * Adds an item of type T to the back of the deque.
     * @param item
     */
    public void addLast(T item) {
        if (size >= items.length) {
            resize(size * RFACTOR);
        }
        if (size == 0) {
            items[itemFirst] = item;
            nextFirst = (itemFirst - 1 + items.length) % items.length;
            nextLast = (itemFirst + 1) % items.length;
            size++;
            return;
        }
        items[nextLast] = item;
        nextLast = (nextLast +1) % items.length;
        size++;
    }

    /**
     * Returns true if deque is empty, false otherwise.
     * @return
     */
    public boolean isEmpty() {
        if (size == 0) {
            return true;
        }
        return false;
    }

    /**
     * Returns the number of items in the deque.
     * @return
     */
    public int size() {
        return size;
    }

    /**
     *  Prints the items in the deque from first to last, separated by a space. Once all the items have been printed, print out a new line.
     */
    public void printDeque() {
        int index = itemFirst;
        for (int i = 0; i < size; i++) {
            System.out.print(items[index]+" ");
            index = (index + 1) % items.length;
        }
        System.out.println();
    }

    /**
     * Removes and returns the item at the front of the deque. If no such item exists, returns null.
     */
    public T removeFirst() {
        if ((double) size / items.length <= 0.25) {
            resize(items.length / RFACTOR);
        }
        if (size == 0) {
            return null;
        }
        size--;
        if (size == 0) {
            nextFirst = itemFirst;
            nextLast = itemFirst;
            return items[itemFirst];
        } else {
            itemFirst = (itemFirst + 1) % items.length;
            nextFirst = (nextFirst + 1) % items.length;
            return items[nextFirst];
        }

    }

    /**
     * Removes and returns the item at the back of the deque. If no such item exists, returns null.
     * @return
     */
    public T removeLast() {
        if ((double) size / items.length <= 0.25) {
            resize(items.length / RFACTOR);
        }
        if (size == 0) {
            return null;
        }
        size--;
        if (size == 0) {
            nextFirst = itemFirst;
            nextLast = itemFirst;
            return items[itemFirst];
        } else {
            nextLast = (nextLast - 1 + items.length) % items.length;
            return items[nextLast];
        }

    }

    /**
     * Gets the item at the given index, where 0 is the front, 1 is the next item, and so forth. If no such item exists, returns null. Must not alter the deque!
     * @param index
     * @return item
     */
    public T get(int index) {
        int k = itemFirst;
        for (int i = 0; i < index; i++) {
            k = (k+1) % items.length;
        }
        return items[k];
    }
}

双向循环链表

数据结构
在这里插入图片描述
实现方法：

  • public LinkedListDeque()初始化一个空的循环双向链表队列
  • public LinkedListDeque(LinkedListDeque other)创建一个与other队列相同的循环队列副本。
  • public void addFirst(T item)在循环队列的头部添加一个新的元素。
  • public void addLast(T item)在循环队列的尾部添加一个新的元素。
  • public boolean isEmpty()判断当前循环队列是否为空。
  • public int size()返回当前链表的大小。
  • public void printDeque()打印当前循环队列的所有元素，元素之间以空格分隔，输出完毕后输出空格。
  • public T removeFirst()删除队列中的头部元素。
  • public T removeLast()删除队列中的尾部元素。
  • public T get(int index)获取当前队列中的index索引处的元素，通过迭代的方式。
  • public T getRecursive(int index)获取当前队列中的index索引出的元素，通过递归的方式。
  • public Iterator<T> iterator()实现Iterable接口的iterator方法，使得循环队列可以用java中foreach语法。
  • public boolean equals(Object obj)复写object类中的equals方法，使得循环队列有正确的比较相等操作。
import java.util.Iterator;
import java.util.NoSuchElementException;

public class LinkedListDeque<T> implements Iterable<T> {
    private DequeNode first;

    private int size;
    public LinkedListDeque() {
        first = null;
        size = 0;
    }

    public LinkedListDeque(LinkedListDeque other) {
        if (other.first == null && other.size() == 0) {
            first = null;
            size = 0;
        }else {
            first = null;
            size = 0;
            for (DequeNode p = other.first; p != other.first.prev; p = p.next) {
               addLast(p.item);
            }
            addLast((T) other.first.prev.item);
        }
    }

    private class DequeNode {
        private T item;
        private DequeNode prev;
        private DequeNode next;

        DequeNode(T i, DequeNode p, DequeNode n) {
            item = i;
            prev = p;
            next = n;
        }
    }


    /**
     * Adds an item of type T to the front of the deque.
     * @param item
     */
    public void addFirst(T item){
        if (first == null) {
            first = new DequeNode(item, null, null);
            first.next = first;
            first.prev = first;
        } else {
            first = new DequeNode(item, first.prev, first);
            first.next.prev = first;
        }
        size++;
    }

    /**
     * Adds an item of type T to the back of the deque.
     * @param item
     */
    public void addLast(T item){
        if (first == null) {
            first = new DequeNode(item, null, null);
            first.next = first;
            first.prev = first;
        } else {
            first.prev = new DequeNode(item, first.prev,first);
            first.prev.prev.next = first.prev;
        }
        size++;
    }

    /**
     * Returns true if deque is empty, false otherwise.
     * @return
     */
    public boolean isEmpty(){
        if (size == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Returns the number of items in the deque.
     * @return
     */
    public int size(){
        return size;
    }

    /**
     *  Prints the items in the deque from first to last, separated by a space. Once all the items have been printed, print out a new line.
     */
    public void printDeque(){
        for (DequeNode p = first; p != first.prev; p= p.next) {
            System.out.print(p.item+" ");
        }
        System.out.print(first.prev.item + " ");
        System.out.println();
    }


    /**
     * Removes and returns the item at the front of the deque. If no such item exists, returns null.
     */
    public T removeFirst(){
        if (isEmpty()) {
            return null;
        }
        size--;
        DequeNode p = first;
        first.prev.next = first.next;
        first.next.prev = first.prev;
        first = first.next;
        return p.item;
    }

    /**
     * Removes and returns the item at the back of the deque. If no such item exists, returns null.
     * @return
     */
    public T removeLast(){
        if (isEmpty()) {
            return null;
        }
        size--;
        DequeNode p = first.prev;
        first.prev.prev.next = first;
        first.prev = first.prev.prev;
        return p.item;
    }

    /**
     * Gets the item at the given index, where 0 is the front, 1 is the next item, and so forth. If no such item exists, returns null. Must not alter the deque!
     * @param index
     * @return item
     */
    public T get(int index){
        if (index < 0 || index >= size) {
            return null;
        }
        DequeNode p = first;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        return p.item;
    }

    private T getRecursiveHelp(int index, DequeNode p) {
        if (index == 0) {
            return p.item;
        }
        return getRecursiveHelp(index-1, p.next);
    }

    /**
     * Gets the item at the given index, where 0 is the front, 1 is the next item, and so forth. If no such item exists, returns null. Must not alter the deque!
     * @param index
     * @return
     */
    public T getRecursive(int index) {
        if (index < 0 || index >= size) {
            return null;
        }
        return getRecursiveHelp(index, first);
    }


    private class DequeIterator implements Iterator<T>{
        private DequeNode current = first;
        int i = 0;

        @Override
        public boolean hasNext() {
            if (i < size) {
                i++;
                return true;
            }
            return false;
        }

        @Override
        public T next() {
            T item = current.item;
            current = current.next;
            return item;
        }
    }

    @Override
    public Iterator<T> iterator() {
        return new DequeIterator();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof LinkedListDeque)) return false;
        LinkedListDeque<?> other = (LinkedListDeque<?>) obj;
        if (this.size != other.size) return false;
        Iterator<T> thisIt = this.iterator();
        Iterator<?> otherIt = other.iterator();
        while (thisIt.hasNext() && otherIt.hasNext()) {
            if (!thisIt.next().equals(otherIt.next())) {
                return false;
            }
        }
        return true;
    }
}

循环队列实现的对比

循环链表队列（LinkedListDeque）

优点：
动态扩展： 链表队列可以根据需要动态地增加节点，不需要事先分配固定的存储空间。
内存利用： 在任何时候，链表都只占用它实际需要的内存空间。
复杂度： 在链表的头部和尾部添加或删除元素都是常数时间的操作（O(1)），因为不需要移动其他元素。
缺点：
内存开销： 每个元素需要额外存储指针信息，这增加了内存的开销。
时间开销： 访问链表中间的元素需要从头节点或尾节点遍历，因此访问时间为线性时间（O(n)）。
缓存不友好： 链表的节点可能在内存中不连续，导致缓存命中率降低，可能影响性能。

循环数组队列（ArrayDeque）

优点：
随机访问： 由于数据连续存储，支持快速随机访问，访问任意元素的时间复杂度为O(1)。
内存连续： 数据存储在连续的内存空间中，有利于提高缓存的利用率。
空间预分配： 初始时即分配一个数组，可以减少内存的频繁分配。
缺点：
固定容量： 初始需要定义数组的大小，虽然可以动态扩容，但这是通过创建新数组并复制旧数组元素来实现的，耗费时间和空间。
扩容成本： 扩容操作涉及到内存的重新分配及数据的复制，特别是当队列大小达到数组容量时，每次添加元素都可能触发扩容，这可能导致较大的性能开销。
可能的空间浪费： 如果队列的使用量远小于数组的实际分配大小，会造成空间浪费。

poison_Program
关注
专栏目录
Proj1a 数据结构：双端队列| CS61B-Spring-2018
qq_46497008的博客
05-30 1518
主要任务 编写双端队列，能够addFirst, remove First, addLast, removeLast.并实现其他一些辅助功能。 使用两种数据结构来完成双端队列，分别是链表和数组。 要求这两种数据结构的add和remove操作都花费O(1)的时间，即与队列长度无关。 LinkedListDeque 主要思路见Week2中的双向链表。主要思路是： 循环链表与哨兵节点：在双向链表中设置一个哨兵节点，它的next永远指向第一个节点，pre永远指向最后一个节点（即使此时链表为空，只有它自己，那么nex
CS61B project 1 笔记
qyx713的博客
04-17 2932
队列这种数据结构的物理实现一般是两种，一种是链表，一种是数组。 1. 带哨兵的双向链表 使用一个sentinel来代替之前的head头指针，sentinel的item没有实际的意义，主要关注它的next和pre，初始的时候，链表只有一个sentinel节点，sentinel.next指向自己，sentinel.pre也指向自己。当添加了若干个节点之后，sentinel.next指向头节点，而s...
CS61B笔记-MaxArrayDeque+Test
m0_65660823的博客
04-14 274
1.不需要implements Comparable<T>，因为MaxArrayDeque<T>的T也是未知的类型，所以就算引入Comparable<T>，也不知道重写compareTo方法时比较什么（Comparable是基本的比较）主要是在Test中使用不同，test中首先需要new一个Comparator，因此在new MaxArrayDeque的时候必须用有参构造器来new,因为myComparator 是此类的一个成员，不能没有！总结反思：这道题让我更理解。
UCBerkeley cs61b-你值得拥有的数据结构神课
weixin_63962760的博客
10-15 1241
cs61b作为UCBerkeley的数据结构与算法课程，全面地讲述了各种经典的数据结构和算法，主讲教授Josh Hug也会经常性地从学生的角度带着我们编写代码并发现容易出错的地方，Josh Hug在课上还会拿身边的例子来说明数据结构和算法，比如讲bag的时候拿起了自己的大袜子，而且课上也会涉及到一些我们国家的东西，真的是最最可爱的老师！！！课程slides中也会包含很多动画给我们展示算法的一步步流程，extremely animated、explict and straightforward.
cs61b实验记录（八）project 3：BearMaps 基于OSM的伯克利地图web应用
qq_45698833的博客
04-23 1992
cs61b实验记录（八）project 3:BearMaps https://github.com/BoL0150/Berkeley-cs61b Application Structure Your job for this project is to implement the back end of a web server. To use your program, a user will open an html file in their web browser that displays a m
伯克利神课 CS61B 游戏项目 Project3 建立我的世界（地图生成）
lindaicoding的博客
07-26 3236
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 这是一个大的project，前前后后我断断续续做了一个月。真正自己的从无到有设计的迷宫出来的时候是很兴奋的。这个project老师给出的start code很少，不像BearMap骨架很清晰，自己思考怎样算法实现就是了。Project3 更倾向于让你从头到尾设计一个自己的小世界，不局限什么方法，也不限制方法的复杂度
2019CS61B的HW1、Lab6、Lab7 、 project1A和project1B
paleatta的博客
05-24 1618
HomeWork0 和 project0 没有 HomeWork太简单了 project0 看着太烦躁了 所以就从project1a开始 这个博客先放到这里 后面慢慢填坑 project1a public class LinkedListDeque<Generic> { //泛型节点类 private class GenericNode { public Generic item; public GenericNode next;
HW1 | 吉他拟音 | CS61B-Spring-2018
qq_46497008的博客
06-10 740
接口和抽象类的用法： 接口常常有一串层次结构，这些接口由抽象类继承，并提供默认实现。抽象类又由具体的类继承。一个很好的例子是Collection接口：它扩展了Iterable（它的超级接口），并由许多子接口（即List，Set，Map）实现，而这些子接口又具有自己的抽象实现（AbstractList，AbstractSet AbstractMap） （关于接口中的default方法与抽象类中的方法，我的理解是，default方法无法代替抽象类方法，因为接口中没有实例变量，许多方法无法实现（比如getter和
CS61B project 2 示例图的地牢地图房间走廊地图生成洞穴地图生成方法
锐龙处理器
08-14 1695
本文是针对 CS61B 学习的 proj 2 的部分内容的笔记。 Josh 做的例子是这样的： 我做的地牢的基于洞穴的版本大致就这样（地图应该调平滑点洞穴减少直线的路）。 基本方案是使用 Cellular Automata 演变，然后用某种策略联通不联通的洞穴。（设计多种可走路径才比较趣味）。 然后是模仿 Josh 的版本做的矩形房间和通道的版本： 从 Cave 开始，之后在讲怎么做 josh 的版本。 Cellular Automata 邻居分布有 摩尔型 Mo...
CS61B:实验室，CS61B的作业
03-28
在CS61B的实验室作业中，学生将学习Java的基础语法，包括变量、数据类型、控制流（如if语句、for循环、while循环）、方法定义与调用、类与对象等。 2. **面向对象编程**：Java的核心在于其面向对象的特性，学生将...
CS61B：CS61B练习
02-09
在CS61B的练习中，你可能会遇到各种挑战，如编写递归函数、实现排序算法、设计数据结构（如栈、队列、树和图）以及解决实际问题的案例。通过这些练习，你可以逐步熟练掌握Java编程，同时加深对数据结构和算法的理解...
cs61b:这是Berekley类CS61B的存储库，我根据类框架存储库保存我的工作
03-17
在CS61B课程中，学生将学习如何使用Java来实现各种数据结构，如数组、链表、栈、队列、树和图，以及算法，如排序和搜索。 【知识点】： 1. **Java基础**：包括变量、控制流（if-else，循环）、类和对象、继承、多态...
cs61b-textbook-zh：[翻译] UCB CS61b Java中的数据结构
02-05
《UCB CS61b Java中的数据结构》是加州大学伯克利分校（UC Berkeley）CS61b课程的教材，这门课程专注于教授Java语言中的数据结构与算法。这个翻译版为中文读者提供了深入理解Java编程语言中数据结构概念的机会。让...
CS61B
02-14
数据结构是CS61B的另一个重点，它涵盖了数组、链表、栈、队列、树、图等多种数据组织形式。这些数据结构的选择和使用直接影响到算法的效率和程序的性能。课程会详细介绍每种数据结构的实现、操作以及适用场景，并...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 462
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
Indigo____的博客
10-04 334
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
数据结构-4.1.特殊矩阵的压缩存储
ADCvbV的博客
10-01 1039
1.知道一维数组的起始地址，就可以求出任意下标对应的元素所在的地址；2.注：如果数组下标从1开始，上述公式的i就要改为i-1；3.数组里的元素类型相同，因此所占空间也相同。1.注：数组的存储是连续(计算机的存储是线性的)的，针对非线性的二维数组，为了将其拉成线性结构，就有了行优先和列优先两种存储方式；2.将非线性的二维数组整成线性的好处就是可以实现随机存取；3.行优先时计算存储地址：公式中i为行，j为列4.列优先时计算存储地址：公式中i为行，j为列由于对称矩阵关于主对角线对称，因此在存储对称矩阵的数据时只需
浙大数据结构：07-图4 哈利·波特的考试
最新发布
qq_74924951的博客
10-05 853
floyd算法
C++语言笔试试题精华：栈与队列、二分查找与存储结构
2. 第二题关注循环队列的结构和操作。循环队列虽然有两个指针，但依然是线性结构。队头和队尾指针共同决定了队列元素的数量，选项D是正确的。这提示了考生对循环队列内部机制的掌握。 3. 第三题考核二分查找算法的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

poison_Program

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值