使用java语言实现一个队列(两种实现比较)(数据结构)

一.什么是队列,换句话说,队列主要特征是什么?

四个字:先进先出

六个字:屁股进,脑袋出

脑补个场景:日常排队买饭,新来的排在后面,前面打完饭的走人,这就是队列;

OK,思考一个问题,我为什么写了两种实现,它们的区别是什么,哪个性能更好一些?

我觉得学习一定要带着问题来学习;

二.队列的两种实现

1.数组队列

数组队列比较简单,基于之前写的动态数组所实现的,基本方法都是根据队列特性从而选择性的调用动态数组的方法来实现的。

public class ArrayQueue<E> implements Queue<E> {
    private Array<E> array;

    public ArrayQueue (int catacity) {
        array = new Array<E>(catacity);
    }

    public ArrayQueue () {
        array = new Array<E>();
    }
    //查看队列容量
    public int catacity () {
        return array.getCapacity();
    }
    //获取队列中元素个数
    @Override
    public int getSize() {
        return array.getSize();
    }
    //判断队列是否为空
    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }
    //入队 时间复杂度:O(1)
    @Override
    public void enqueue(E e) {
        array.addLast(e);
    }
    //出队 时间复杂度:O(n)
    @Override
    public E dequeue() {
        return array.removeFirst();
    }
    //查看队首元素 时间复杂度: O(1)
    @Override
    public E getFront() {
        return array.getFirst();
    }
    @Override
    public String toString () {
        StringBuilder res = new StringBuilder();
        res.append("Queue");
        res.append("front [");
        for (int i = 0; i < getSize(); i++) {
            res.append(array.getByIndex(i));
            if (i != array.getSize() - 1) {
                res.append(",");
            }
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main (String[] args) {
        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        for(int i = 0; i < 10; i++) {
            arrayQueue.enqueue(i);
            System.out.println(arrayQueue);
            if (i % 3 == 2) {
                System.out.println(arrayQueue);
            }
        }
    }
}

2.循环队列

什么是循环队列?用图来说明

(1)队首在0位置,队尾在4位置,队列里面有4个元素

(2)此时,我进行两次出队操作,队首位置为2,队首前面空了两个空间。

 (3)我再进行三次入队操作,其中一个元素插到了数组的前面。

循环队列:就是当数组末端没有位置时,新的入队元素则插到数组前面空余的空间中,避免了空间的浪费,可以把整个数组想象成一个环状。

代码实现:

public class LoopQueue<E> implements Queue<E> {

    private E[] data;
    //队首
    private int front;
    //队尾
    private int tail;
    //队列中元素个数
    private int size;

    public LoopQueue (int catacity) {
        //实际开辟的容量比用户定义的容量大一位
        data = (E[])new Object[catacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue () {
        this(10);
    }
    //获取队列容量
    public int getCapacity () {
        return data.length - 1;
    }
    //获取队列元素个数
    @Override
    public int getSize() {
        return size;
    }

当front == tail 时,定义队列为空

//队列是否为空
    @Override
    public boolean isEmpty() {
        return tail == front;
    }
    //入队
    @Override
    public void enqueue(E e) {
        //判断数组空间满没满,满了的话进行扩容
        if ((tail + 1) % data.length == front) {
            resize(getCapacity() * 2);
        }

       data[tail] = e;
       tail = (tail + 1) % data.length;
       size ++;
    }
    //出队
    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        E set = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size --;
        //缩容
        if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
            resize(getCapacity()/2);
        }
        return set;
    }
    //获取队首元素
    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Queue is empty.");
        }
        return data[front];
    }

    //扩容
    public void resize (int catacity) {
        E[] newArray = (E[])new Object[catacity];
        //将旧数组中元素复制到新数组中
        for (int i = 0; i < size; i++) {
            newArray[i] = data[(i + front) % data.length];
        }
        data = newArray;
        front = 0;
        tail = size;
    }

    @Override
    public String toString () {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("LoopQueue");
        stringBuilder.append("front [");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(data[(i + front) % data.length]);
            if (i != size - 1) {
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("] tail");
        return stringBuilder.toString();
    }

循环队列总结:

三.两种队列的简单比较

分别用数组队列和循环队列,将10万个数,入队再出队;

 public static Double testQueue (Queue<Integer> queue, int opCount) {

        long startTime = System.nanoTime();
        Random random = new Random();

        for (int i = 0; i < opCount; i++) {
            queue.enqueue(random.nextInt(Integer.MAX_VALUE));
        }
        for (int i = 0; i < opCount; i++) {
            queue.dequeue();
        }

        long endTime = System.nanoTime();
        return ( endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;
        Queue<Integer> loopQueue = new LoopQueue<>();
        Queue<Integer> arrayQueue = new ArrayQueue<>();
        System.out.println("ArrayQueue, time1 = " + Main.testQueue(arrayQueue,opCount));
        System.out.println("LoopQueue, time2 = " + Main.testQueue(loopQueue,opCount));

        //new Main().stack();
    }

测试结果:两者差距近200倍。

最后,

浮于表面看千遍,

不如自己思一遍,

希望这篇文章能够对你起到帮助。

原文地址:https://www.cnblogs.com/inu6/p/11759984.html

时间: 2024-10-10 04:50:41

使用java语言实现一个队列(两种实现比较)(数据结构)的相关文章

java语言实现快速排序的两种方式

方法一: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 public class QuickSortExp1{     public static void main(String[] args){         int[] sortArray = new int[]{5,7,4,2,9,8,3,6};         System.out

java 程序执行输出有两种简单方式

java 程序执行输出有两种简单方式: 1. System.out.println("需要输出的内容"): 该方法可参看运行一个简单的Java程序 结果图: 2. System.out.print("需要输出的内容"): 1 public class HelloWorld 2 { 3 //Java程序的入口方法,程序将从这里开始运行 4 public static void main(String[] args) 5 { 6 //向控制台打印一条语句 7 Syste

java连接sql server2008的两种方法

最近学到java连接数据库(sql server),发现常用的我们有两种方法,那么这里我总结一下这两种方法怎么使用,还有它们的区别,还有我们一般要使用哪一种方法. 方法一:使用jdbc-odbc桥连接sql server,作为中间媒介连接数据库; 注意我们每次在连接数据库前都必须要引入sql包:import java.sql.*;接下来的步骤都是习惯性步骤,我这里就按照每一步的使用进行列举: 1.配置数据源:打开控制面版->管理工具->数据源(ODBC)->(一般而言我们使用用户DSN)

C语言中数据的两种属性及static的作用

C语言中数据有两种属性:数据类型和存储类别.数据类型定义了数据格式(长度),存储类别定义了数据的作用域和生命期. 1.变量的声明 1.1 变量的声明的一般形式:存储类别 数据类型 变量名;数据类型以int为例: 自动变量:auto int i;//自动变量是局部变量 局部变量:在函数内部定义的变量,局部变量缺省存储类别时就是自动变量 作用域:从定义开始到函数结束. 生命期:从函数调用开始到函数推出为止. 外部变量/全局变量:在函数外部定义而没有指出存储类别的变量 定义外部变量:extern in

java中实现多线程的两种基本方法

java中实现多线程有两种基本方法,一种是继承Thread, 另一种是实现Runnable接口. 但是因为java中子类只能继承一个父类,如果采用继承Thread类,就不能继承其他类,很受限制. 以下是采用继承Thread类的例子: public class MyThreadTest{ public static void main(String[] args){ MyThread amythread1=new MyThread("my thread 1"); MyThread amy

java基础知识回顾之java Thread类学习(三)--java线程实现常见的两种方式实现好处:

总结:实现Runnable接口比继承Thread类更有优势: 1.因为java只能单继承,实现Runnable接口可以避免单继承的局限性 2.继承Thread类,多个线程不能处理或者共享同一个资源,但是实现Runnable接口可以处理同一个资源. 下面我们做个测试:验证下.车站的售票系统售票的例子,车站的各个售票口相当于各个线程,我们先使用第一种方法几继承Thread类的方式实现: 代码如下: package com.lp.ecjtu.Thread; /** * * @author Admini

Java中Compareable和Comparator两种比较器的区别

Java中Compareable和Comparator两种比较器的区别 1.引言 在java这个处处是对象的世界里,对两个对象进行按某一属性进行比较是特别常见的需求.比如书店中的书按照价格比较,亦或者是学生按照成绩进行排名等等. 对于JDK8而言,有三种实现对象比较的方法: 1.在需要比较的对象类中覆写Object类的equals()方法: 2.需要比较的类继承Comparable接口,然后在其类内部实现compareTo()方法: 3.抛去需要被比较的类,在其外部自定义一个单独的对象比较器,继

css如何实现一个文字两种颜色代码实例

css如何实现一个文字两种颜色代码实例:在实际应用中可能需要设置文本效果比较炫酷.有一种效果就是将一个文字设置为两种颜色,使用普通的方法肯定是无法实现.下面就分享一下实现此功能的代码实例: <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <meta name="author" content="http://www.softwhy.com/&qu

java中设置代理的两种方式

1 前言 有时候我们的程序中要提供可以使用代理访问网络,代理的方式包括http.https.ftp.socks代理.比如在IE浏览器设置代理. 那我们在我们的java程序中使用代理呢,有如下两种方式.直接上代码. 2 采用设置系统属性 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 import jav