Java数据结构和算法（三）--栈



栈（ 英语：stack）又称为堆栈或堆叠，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

　　栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。

　　由于堆叠数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。栈也称为后进先出表。

　　这里以羽毛球筒为例，羽毛球筒就是一个栈，刚开始羽毛球筒是空的，也就是空栈，然后我们一个一个放入羽毛球，也就是一个一个push进栈，当我们需要使用羽毛球的时候，从筒里面拿，也就是pop出栈，但是第一个拿到的羽毛球是我们最后放进去的。

初级栈实现：

package com.ys.datastructure;

public class MyStack {
	private int[] array;
	private int maxSize;
	private int top;
	//初始化栈
	public MyStack(int size){
		maxSize = size;
		array = new int[maxSize];
		top = -1;
	}
	//压入数据
	public void push(int value){
		if(top < maxSize - 1){
			array[++top] = value;
		}
	}
	//弹出数据
	public int pop(){
		return array[top--];
	}
	//查看栈顶元素
	public int peek(){
		return array[top];
	}
	//判断栈是否为空
	public boolean isEmpty(){
		if(top == -1){
			return true;
		}else{
			return false;
		}
	}
	//判断栈是否满
	public boolean isFull(){
		if(top == maxSize - 1){
			return true;
		}else{
			return false;
		}
	}
}

以上的简单栈只能存储整型数据，且无法扩容。下面我们实现一个可以存储任意类型数据且自动扩容的栈。

package com.ys.datastructure;
import java.util.Arrays;
import java.util.EmptyStackException;

public class ArrayStack {
	//采用Object存储数据，因为Object可用存储任意类型数据
	private Object[] elementData;
	//定义栈大小
	private int maxSize;
	//定义栈顶
	private int top;
	//初始化栈，默认大小为10
	public ArrayStack(){
		maxSize = 10;
		elementData = new Object[maxSize];
		top = -1;
	}
	//初始化栈
	public ArrayStack(int Size){
		if(Size < 0){
			throw new IllegalArgumentException("初始化栈大小不能小于0：" + Size);
		}
		maxSize = Size;
		elementData = new Object[maxSize];
		top = -1;
	}
	//压栈，压栈前判断是否栈满，栈满就扩容
	public void push(Object value){
		isGrow(top+1);
		elementData[++top] = value;
	}
	//出栈
	public Object pop(){
		return elementData[top--];
	}
	//查看栈顶元素
	public Object peek(){
		if(top == -1){
			throw new EmptyStackException();
		}
		return elementData[top];
	}
	//判断栈是否为空
	public boolean isEmpty(){
		if(top == -1){
			return true;
		}else{
			return false;
		}
	}
	//移除栈顶元素
	public void remove(){
		elementData[top] = null;
		top--;
	}
	//判断是否栈满，满则扩容
	public boolean isGrow(int minCapacity){
		if(minCapacity < maxSize){
			return false;
		}else{
			maxSize = maxSize * 2;
			elementData = Arrays.copyOf(elementData, maxSize);
			return true;
		}
	}
}

利用栈实现字符串逆序输出：

//利用栈，输出字符串的逆序
	public static void testStringReversal(String str){
		char[] cha = str.toCharArray();
		ArrayStack stack = new ArrayStack();
		for(char c : cha){
			stack.push(c);
		}
		while(!stack.isEmpty()){
			System.out.print(stack.pop());
		}
	}

数据入栈和出栈的时间复杂度都为O(1)，也就是说栈操作所耗的时间不依赖栈中数据项的个数，因此操作时间很短。而且需要注意的是栈不需要比较和移动操作，我们不要画蛇添足。