用单链表与数组实现队列先进先出的数据结构

1.自定义Node.java实体类：

package data_table.syn.com.common.util;

/**

 * 简单封装Node节点

 * @author Administrator

 *

 */

public class Node {

private Object value;// 值
private Node next; // 下一个对象的地址值
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}

public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public Node() {
super();
// TODO Auto-generated constructor stub
}
public Node(Object value) {
super();
this.value = value;
}

}

2.数组实现队列先进先出的数据结构：

package data_table.syn.com.common.util;

/**

 * 数组实现队列结构，先进先出

 * @author Administrator

 *

 */

public class QueueByArray {
private int size=0;
private Object[] que=new Object[8];

public int size() {
return size;
}
/**
* 进队列
* @param object
*/
public void enQue(Object value) {
if (size>=que.length) {
Object[] stemp=new Object[que.length*2];
for(int i=0;i<que.length;i++) {
stemp[i]=que[i];

}
que=stemp;
}else {

que[size]=value;
}

size++;
}
/**
* 出队列
* @return
*/
public Object deQue() {
if(size<=0) {
throw new ArrayIndexOutOfBoundsException();
}

Object value=que[0]; // 取出第一个存储的值
que[0]=null;
if (size>1) {
for(int i=1;i<size;i++) {
que[i-1]=que[i];

}
}
size--;
return value;
}

}

3.单链表实现队列的先进先出的数据结构：

package data_table.syn.com.common.util;

/**

 * 但链条实现队列结构，先进先出

 * @author Administrator

 *

 */

public class QueueByLink {
private int size=0;
private Node head=null;
//private Node behind=null;

public int size() {
return this.size;
}
/**
* 进队列
* @param object
*/
public void enQue(Object value) {
Node newNode=new Node(value);
if (head==null) {
head=newNode;
}else {
/*if (behind==null) { //第二节点
Node temp=head;
while (temp.getNext()!=null) {
temp=temp.getNext();
}
temp.setNext(newNode);
behind=temp;
}else { // 多个节点
behind.setNext(newNode);
behind=behind.getNext();
}*/
Node temp=head;
while (temp.getNext()!=null) {
temp=temp.getNext();
}
temp.setNext(newNode);

}
size++;

}
/**
* 出队列
* @return
*/
public Object deQue() {
if (size<=0) {
throw new ArrayIndexOutOfBoundsException();
}
Object value=head.getValue();
if (size==1) {
head=null;
return value;
}
head=head.getNext(); // 将头付给它的下一个节点
return value;

}

}

4.比较性能：

a1)数组进队列：当存储在数组的长度内，数组直接拿到数组的size,可以直接存值，当存值超出数组的长度，数组需要扩容，性能消耗较大。

a2)链条进队列：遍历整个链条，取到最后的node节点，存值。

比较：当存值一定，数组进队列要比链条性能好的多。当存值不定时，性能数组稍差，综合考虑，数组进队列稍胜一筹。

b1)数组出队列：拿到数组的第一个值出队列，然后将数组其他的元素向前移动，性能较差。数据越大，性能越差。

b2)链条出队列：拿到head节点出队列，将他的下一个节点赋值为head节点，效率非常高。

比较：链条远胜于数组
综合比较：数组与但链条实现队列不分胜负。
注意:单针对我自己实现的基础上。可以优化。