Java栈的实现

Java栈的实现

栈 是限制仅在表的一端进行插入和删除运算的线性表。

• 插入或删除的一端为栈顶，另一端称为栈底
• 当表中没有元素时为空栈
• 栈为后进先出的线性表，又称LIFO表

栈没有查找操作，查看非栈顶元素的唯一方式是反复从栈中删除元素，直到想要的元素位于栈顶。

栈的操作：

• push(newEntry)：将新元素插入栈顶
• pop()：删除栈顶元素并返回值
• peek：返回栈顶元素但不删除

栈的接口操作

public interface StackInterface<T> {
	public void push(T newEntry);
	public T pop();
	public T peek();
	public boolean isEmpty();
	public void clear();
}

基于链表的实现

使用链表表示栈，则第一个结点应该引用栈顶元素。

基于链表的栈实现类

public class LinkedStack<T> implements StackInterface<T>{
	
	private Node topNode;
	
	public LinkedStack() {
		topNode=null;
	}

	@Override
	public void push(T newEntry) {
		System.out.print(newEntry+" ");
		Node newNode=new Node(newEntry);
		newNode.setNextNode(topNode);
		topNode=newNode;
	}

	@Override
	public T pop() {
		T top=null;
		if(topNode!=null){
			top=topNode.getData();
			topNode=topNode.getNextNode();
		}
		return top;
	}

	@Override
	public T peek() {
		T top=null;
		if(topNode!=null)
			top=topNode.getData();
		return top;
	}

	@Override
	public boolean isEmpty() {
		return topNode==null;
	}

	@Override
	public void clear() {
		topNode=null;
	}
	
	private class Node {
		private T element;
		private Node next;
		private Node(T element) {
			this(element,null);
		}
		
		private Node(T element,Node next){
			this.element=element;
			this.next=next;
		}
		
		private T getData(){
			return element;
		}
		
		private void setData(T newData){
			element=newData;
		}
		
		private Node getNextNode(){
			return next;
		}
		
		private void setNextNode(Node nextNode){
			next=nextNode;
		}
	}
}

测试代码

public class main_Linked {

	private static LinkedStack<Integer> stack;
	public static void main(String[] args) {
		stack=new LinkedStack<Integer>();
		Random ra =new Random();
		for(int i=0;i<20;i++)
			stack.push(ra.nextInt(100));
		System.out.println();
		for(int i=0;i<20;i++)
			System.out.print(stack.pop()+" ");
	}
}

基于数组的实现

使用数组实现栈，数组的第一个元素应该表示栈底，而数组中最后一个被占据的位置应该表示栈顶。

基于数组的栈实现类

public class ArrayStack<T> implements StackInterface<T>,Serializable {
	
	private T[] stack;
	private int topIndex;
	private static final int DEFAULT_MAX=50;
	
	public ArrayStack() {
		this(DEFAULT_MAX);
	}

	public ArrayStack(int initialCapacity) {
		stack=(T[]) new Object[initialCapacity];
		topIndex=-1;
	}
	
	private void doubleArray(){
		T[] oldArray=stack;
		stack=(T[]) new Object[2*oldArray.length];
		System.arraycopy(oldArray, 0, stack, 0, oldArray.length);
	}
	
	@Override
	public void push(T newEntry) {
		System.out.print(newEntry+" ");
		topIndex++;
		if(topIndex>=stack.length)
			doubleArray();
		stack[topIndex]=newEntry;
	}

	@Override
	public T pop() {
		T top=null;
		if(!isEmpty()){
			top=stack[topIndex];
			stack[topIndex]=null;
			topIndex--;
		}
		return top;
	}

	@Override
	public T peek() {
		T top=null;
		if(!isEmpty())
			top=stack[topIndex];
		return top;
	}

	@Override
	public boolean isEmpty() {
		return topIndex<0;
	}

	@Override
	public void clear() {
		while(!isEmpty())
			pop();
	}
}

测试代码

public class main_Array {

	private static ArrayStack<Integer> stack;
	public static void main(String[] args) {
		stack=new ArrayStack<Integer>();
		Random ra =new Random();
		for(int i=0;i<20;i++)
			stack.push(ra.nextInt(100));
		System.out.println();
		for(int i=0;i<20;i++)
			System.out.print(stack.pop()+" ");
	}
}

无论是基于数组还是基于链表，栈的所有操作都是O(1)，但数组被填满时，push将加倍原数组长度，在这种情况下，push是O(n)的。