一、实现方法
1.同时对循环队列和数组队列入队、出队opCount次;
2.用两个System.nanoTime来算出中间代码的执行时间;
3.导入import java.util.Random包,并使用Random中的nextInt(max),其中的max是指输入0-max间的随机数
二、具体代码
package IMUHERO;
import java.util.Random;
public class Main {
public static double TestQueue(Queue<Integer> q,int opCount){
long startTime =System.nanoTime();
Random random=new Random();
for(int i=0;i<opCount;i++){
q.enqueue(random.nextInt(Integer.MAX_VALUE));
}
for (int i=0;i<opCount;i++){
q.dequeue();
}
long endTime=System.nanoTime();
return (endTime-startTime)/1000000000.0;
}
public static void main(String[] args) {
int opCount=100000;
ArrayQueue<Integer>arrayQueue=new ArrayQueue<>();
double Atime=TestQueue(arrayQueue,opCount);
System.out.println(Atime);
LoopQueue<Integer>loopQueue=new LoopQueue<>();
double Ltime=TestQueue(loopQueue,opCount);
System.out.println(Ltime);
}
}
三、由于上一节课没有贴出arrayQueue的代码,在此进行补充,同样也是继承Queue这个接口来计算;
package IMUHERO;
public class ArrayQueue<E>implements Queue<E> {
Array<E> arrayqueue;
ArrayQueue(int capacity){
arrayqueue=new Array<>(capacity);
}
ArrayQueue(){
this(10);
}
@Override
public int getSize(){
return arrayqueue.getSize();
}
public int getCapacity(){
return arrayqueue.getCapacity();
}
@Override
public boolean isEmpty(){
return arrayqueue.isEmpty();
}
@Override//入队
public void enqueue(E e){
arrayqueue.addLast(e);
}
@Override//出队
public E dequeue(){
return arrayqueue.removeFirst();
}
@Override
public E getFront(){
return arrayqueue.getFirst();
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append(String.format("ArrayQueue: size = %d , capacity = %d\n", arrayqueue.getSize(), arrayqueue.getCapacity()));
res.append('[');
for(int i = 0 ; i < arrayqueue.getSize() ; i ++){
res.append(arrayqueue.get(i));
if(i != arrayqueue.getSize() - 1)
res.append(", ");
}
res.append(']');
return res.toString();
}
}
四、最终结果:
3.9484546
0.0141529
五、结果分析:
由于arrayQueue出队每一个元素的时候都需要把之后所有队列中的元素向前移动一个位置,所以复杂度为O(n),相对于LoopQueue复杂度更高,并且相差倍数非常大。因此在工程中会使用循环队列来减小时间复杂度。
注:关于数据结构的所有代码都放在我的Github上,有需要的同学可以自行Fork,如果觉得还不错,可以打个☆Star哦~~~