栈
接口
public interface Stack<E> {
void push(E e);
E pop();
E peek();
int getSize();
boolean isEmpty();
}
基于Array数组的栈的实现
public class ArrayStack<E> implements Stack<E> {
private Array<E> array;
public ArrayStack(int capacity){
array = new Array<>(capacity);
}
public ArrayStack(){
array = new Array<>();
}
public int getCapacity(){
return array.getCapacity();
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public void push(E e) {
array.addLast(e);
}
@Override
public E pop() {
return array.removeLast();
}
@Override
public E peek() {
return array.get(0);
}
@Override
public String toString() {
StringBuilder ret = new StringBuilder();
ret.append("Stack: ");
ret.append("[");
for (int i = 0; i < array.getSize(); i++) {
ret.append(array.get(i));
if (i != array.getSize() -1)
ret.append(", ");
}
ret.append("] top");
return ret.toString();
}
}
队列
先进先出,FIFO
队列接口
public interface Queue<E> {
void enqueue(E e);
E dequeue();
E getFront();
int getSize();
boolean isEmpty();
}
1. 数组队列
- 出队操作时间复杂度高
Array数组实现队列
public class ArrayQueue<E> implements Queue<E> {
private Array<E> array;
public ArrayQueue(int capacity){
array = new Array<>(capacity);
}
public ArrayQueue(){
array = new Array<>();
}
public int getCapacity(){
return array.getCapacity();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public void enqueue(E e) {
array.addLast(e);
}
@Override
public E dequeue() {
return array.removeFirst();
}
@Override
public E getFront() {
return array.get(0);
}
@Override
public String toString() {
StringBuilder ret = new StringBuilder();
ret.append("Queue: ");
ret.append("Front [");
for (int i = 0; i < array.getSize(); i++) {
ret.append(array.get(i));
if (i != array.getSize() -1)
ret.append(", ");
}
ret.append("] tail");
return ret.toString();
}
}
循环队列
- front指向队首的元素,tail指向队尾第一个入队位置__如果 front == tail 队列为空;
- tail+1 == front 表示队列满,浪费capacity的一个空间;
- 出队均摊时间复杂度为O(1);
public class LoopQueue<E> implements Queue<E>{
private E[] data;
private int front;
private int tail;
private int size; //可以不添加这个变量
public LoopQueue(int capacity){
//申请比用户需要的空间+1
data = (E[]) new Object[capacity+1];
front = tail = 0;
size = 0;
}
public LoopQueue(){
this(10);
}
public int getCapacity(){
return data.length - 1;
}
@Override
public boolean isEmpty() {
return front == tail;
}
@Override
public int getSize() {
return size;
}
@Override
public void enqueue(E e) {
if ((tail + 1) % data.length == front)
resize(getCapacity() * 2);
data[tail] = e;
tail = (tail + 1) % data.length;
size++;
}
private void resize(int newCapacity){
E[] newData = (E[]) new Object[newCapacity+1];
//第一章遍历方式
for (int i = 0; i < size; i++) {
newData[i] = data[(i+front)%data.length];
}
data = newData;
front = 0;
tail = size;
}
@Override
public E dequeue() {
if (isEmpty())
throw new IllegalArgumentException("failed");
E ret = data[front];
data[front] = null;
front = (front+1)%data.length;
size--;
if (size == getCapacity()/4 && getCapacity()/2 != 0){
resize(getCapacity()/2);
}
return ret;
}
@Override
public E getFront() {
if (isEmpty())
throw new IllegalArgumentException("failed");
return data[front];
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("Queue: size = %d , capacity = %d\n", size, getCapacity()));
res.append("Front [");
//第二种遍历方式
for(int i = front ; i != tail ; i = (i+1)%data.length){
res.append(data[i]);
if( (i+1)%data.length != tail )
res.append(", ");
}
res.append("] tail");
return res.toString();
}
}
3. 性能对比
- 对比数组队列和循环队列的性能差异
public class Main {
//测试时间,返回秒
private static double testQueue(Queue<Integer> q,int opCount){
long start = System.currentTimeMillis();
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 end = System.currentTimeMillis();
return (end-start) / 1000.0;
}
public static void main(String[] args) {
int opCount = 100000;
ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
LoopQueue<Integer> loopQueue = new LoopQueue<>();
double time1 = testQueue(arrayQueue,opCount);
double time2 = testQueue(loopQueue,opCount);
System.out.println("ArrayQueue/LoopQueue of time is " + time1 / time2);
}
}