Java数据结构与算法——栈（stack）

一、栈的定义（后进先出的线性表（Last In First Out））

• 栈（stack）—— 限定仅在表尾进行插入和删除操作的线性表；
• 栈顶（top）—— 允许插入和删除的一端；
• 栈底（bottom）——栈顶的另一端；
• 空栈——不含任何元素的栈。

二、栈的抽象数据类型

public interface StackADT {
	
	public boolean isEmpty();// 判空
	
	public boolean isFull();// 判满
	
	public int size();// 栈的大小
	
	public boolean push(Object element);// 进栈
	
	public Object pop();// 出栈
	
	public Object peek();// 返回栈顶对象的一个引用

}

三、栈的顺序存储结构及实现

栈的顺序存储其实是线性表顺序存储的简化，完整代码如下：

public class SequenceStack implements StackADT{
	private Object[] array;// 存储元素
	private int top;// 栈顶元素的索引
	
	// 创建长度为5的空栈
	public SequenceStack() {
		array = new Object[5];
		top = -1;// 通常把空栈判定为top = -1
	}

	@Override
	// 判空
	public boolean isEmpty() {
		return top == -1;
	}
	
	@Override
	// 判满
	public boolean isFull() {
		return top == array.length - 1;
	}

	@Override
	// 栈的大小
	public int size() {
		return top + 1;
	}

	@Override
	// 进栈(进栈需判满)
	public boolean push(Object element) {
		if(isFull()){// 满栈需要扩容
			expand();
		}
		array[top + 1] = element;
		top++;
		return true;
	}

	@Override
	// 出栈(出栈需判空)
	public Object pop() {
		if(isEmpty()){
			return null;
		}else{
			Object temp = array[top];
			array[top] = null;
			top--;
			return temp;
		}
	}

	@Override
	// 访问栈顶元素
	public Object peek() {
		if(!isEmpty()){
			return array[top];
		}
		return null;
	}
	
	// 扩容，扩大两倍
	private void expand(){
		int newLength = (top + 1) * 2;
		array = Arrays.copyOf(array, newLength);
	}
	
	public static void main(String[] args) {
		SequenceStack stack = new SequenceStack();
		for (int i = 0; i < 5; i++) {
			stack.push(i);
		}
		System.out.println(stack.peek());
		stack.pop();
		System.out.println(stack.peek());
		stack.push(5);
		System.out.println(stack.peek());
	}

}

四、栈的链式存储结构及实现

栈的链式存储结构，简称链栈。通常，把栈顶放在单链表的头部。此时，头结点就失去了意义，所以链栈不需要头结点。另外，链栈也不存在栈满的情况，而空栈就是 top == null。完整代码如下：

public class LinkStack<T> {
	// 内部类，节点类
	private class Node{
		private T data;// 数据域
		private Node next;// 指向下一个结点的引用
		
		public Node(){}
		
		public Node(T data, Node next){
			this.data = data;
			this.next = next;
		}
	}
	
	private Node top;// 栈顶结点
	private int size;// 保存栈中元素个数
	
	// 创建空链栈
	public LinkStack(){
		top = null;
	}
	
	// 以给定元素创建链栈，该链栈只有一个元素
	public LinkStack(T element){
		top = new Node(element, null);
		size++;
	}
	
	// 判空
	public boolean isEmpty(){
		return top == null;
	}
	
	// 栈的大小
	public int size(){
		return size;
	}
	
	// 进栈
	public void push(T element){
		//让top指向新创建的元素结点，新元素的next引用指向原来的栈顶元素
		top = new Node(element, top);
		size++;
	}
	
	// 出栈
	public T pop(){
		Node temp = top;
		top = top.next;
		temp.next = null;
		size--;
		return temp.data;
	}
	
	// 返回栈顶元素
	public T peek(){
		return top.data;
	}
	
	public static void main(String[] args){
		LinkStack<String> stack = new LinkStack<String>();
		System.out.println(stack.isEmpty());
		stack.push("kobe");
		stack.push("pual");
		stack.push("jordan");
		stack.push("curry");
		System.out.println(stack.isEmpty());
		System.out.println(stack.size());
		
		System.out.println(stack.peek());
		stack.pop();
		System.out.println(stack.peek());
	}

}