数组与单链表分别实现栈存储

1.自定义Node节点：

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 StackByLink {
Node head=null;
// Node behind=null;
private int size=0;
public int size() {
return size;
}
/**
* 入栈
* @param value
*/
public void push(Object value) {
Node newNode=new Node(value);
if (head==null) {
head=newNode;
}else {
Node temp=head;
while (temp.getNext()!=null) {
temp=temp.getNext();
}
// behind=temp;
// behind.setNext(newNode);
temp.setNext(newNode);
}
size++;
}
/**
* 出栈
* @return
*/
public Object pop() {
if (size<=0) {
throw new ArrayIndexOutOfBoundsException();
}
Object value=null;
Node temp=head;
for(int i=0;i<size-1;i++) {
temp=temp.getNext();
}
value=temp.getValue();
temp.setValue(null);;
size--;
return value;
} 


}

3.数组实现栈结构：

package data_table.syn.com.common.util;
/**
 * 用数组实现栈，先进后出
 * @author Administrator
 *
 */
public class StackByArray {
Object[] stack=new Object[8];
private int size=0;
public int size() {
return size;
}
/**
* 入栈
* @param value
*/
public void push(Object value) {
if (size>=stack.length) {
Object[] stemp=new Object[stack.length*2];
for(int i=0;i<stack.length;i++) {
stemp[i]=stack[i];

}
stack=stemp;
}else {

stack[size]=value;
}

size++;
}
/**
* 出栈
* @return
*/
public Object pop() {
if (size<1) {
throw new ArrayIndexOutOfBoundsException();
}
Object object=stack[size-1];
stack[size-1]=null;
size--;
return object;
} 


}

4.比较两种实现的性能：

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

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

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

b1)数组出栈：拿到数组的size，直接可以拿出第一个进入数组的值，效率非常高。

b2)但链条：遍历整个链条，取到最后的一个拿出。

比较：数组的效率要高于链条。

结论：数组在实现固定长度的栈结构时效率要高于链条实现。