一、数组实现顺序队列
/**
* 顺序队列 此实现会出现假溢出现象
*
* @author Administrator
*
*/
public class MyArrayQueue implements Serializable {
/**
*
*/
private static final long serialVersionUID = 7481149591434803996L;
/**
* 队列中的元素缓存区域
*/
private transient Object[] elementData;
/**
* 队列缓存区域容量
*/
private int capcity = 10;
/**
* 队列中的元素个数
*/
private int size;
/**
* 队头下标
*/
private int font = -1;
/**
* 队尾下标
*/
private int rear = -1;
/**
* 默认构造器
*/
public MyArrayQueue() {
this.elementData = new Object[capcity];
}
/**
* 指定队列初始化容量
*
* @param capcity
* 队列容量
* @throws Exception
* 容量指定为0
*/
public MyArrayQueue(int capcity) throws Exception {
if (capcity == 0)
throw new Exception();
this.capcity = capcity;
this.elementData = new Object[capcity];
}
/**
* 元素入队
*
* @param t
* 入队元素
*/
public void enqueue(T t) {
// 不能插入null元素
if (null == t) {
return;
}
// 队列满
if (rear == (capcity - 1)) {
return;
}
size++;
if (font == rear && rear == -1) {
font++;
}
rear++;
elementData[rear] = t;
}
/**
* 元素出队
*
*/
@SuppressWarnings("unchecked")
public T dequeue() {
// 没有元素
if (size == 0) {
return null;
}
T t = (T) elementData[font];
elementData[font] = null;
size--;
// 只有一个元素
if (font == rear) {
font = -1;
rear = font;
} else {
font++;
}
return t;
}
/**
* 返回当前队列中所有元素的总数
*
* @return 元素长度
*/
public int size() {
return size;
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer();
if (size != 0) {
sb.append("[");
for (Object o : elementData) {
sb.append(o);
sb.append(",");
}
sb.append("]");
return sb.toString();
} else {
return "[]";
}
}
public int getFont() {
return font;
}
public int getRear() {
return rear;
}
}
二、数组实现顺序循环队列
/**
* 顺序循环队列 改写顺序队列,此实现不会出现假溢出现象
*
* @author Administrator
*
*/
public class MyCircularQueue implements Serializable {
/**
*
*/
private static final long serialVersionUID = -1371285437925526528L;
/**
* 队列中的元素缓存区域
*/
private transient Object[] elementData;
/**
* 队列缓存区域容量
*/
private int capcity = 10;
/**
* 队列中的元素个数
*/
private int size;
/**
* 队头下标
*/
private int font;
/**
* 队尾下标
*/
private int rear;
/**
* 默认构造器
*/
public MyCircularQueue() {
this.elementData = new Object[capcity];
}
/**
* 指定队列初始化容量
*
* @param capcity
* 队列容量
* @throws Exception
* 容量指定为0
*/
public MyCircularQueue(int capcity) throws Exception {
if (capcity == 0)
throw new Exception();
this.capcity = capcity;
this.elementData = new Object[capcity];
}
/**
* 元素入队
*
* @param t
* 入队元素
*/
public void enqueue(T t) {
// 元素为null不入队
if (null == t) {
return;
}
// 元素满,将缓冲数组容量扩大一倍,拷贝原有元素后再入队,注意创建新数组后,需要将队尾rear的下标设置为老数组的长度
if (font == (rear + 1) % capcity) {
// 扩容
Object[] newElementData = new Object[capcity * 2];
// 拷贝
int i = 0;
while(font != rear){
newElementData[i] = elementData[font];
font = (font + 1) % capcity;
i ++;
}
font = 0;
rear = i;
elementData = newElementData;
capcity = elementData.length;
// 入队
enqueue(t);
} else {
size++;
elementData[rear] = t;
rear = (rear + 1) % capcity;
}
}
/**
* 元素出队
*
*/
@SuppressWarnings("unchecked")
public T dequeue() {
// 队列空不出队
if (size == 0 || font == rear) {
return null;
}
T t = (T) elementData[font];
elementData[font] = null;
font = (font + 1) % capcity;
size--;
return t;
}
/**
* 返回当前队列中所有元素的总数
*
* @return 元素长度
*/
public int size() {
return size;
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer();
if (size != 0) {
sb.append("[");
for (Object o : elementData) {
sb.append(o);
sb.append(",");
}
sb.append("]");
return sb.toString();
} else {
return "[]";
}
}
public int getFont() {
return font;
}
public int getRear() {
return rear;
}
}