Java数据结构和算法学习（三）—— 栈

Java数据结构和算法学习（三）—— 栈

前言

数组更多的是用来进行数据的存储，纯粹用来存储数据的数据结构，我们期望的是插入、删除和查找性能都比较好。对于无序数组，插入快，但是删除和查找都很慢，为了解决这些问题，后面会学习二叉树、哈希表的数据结构。
栈和队列更多的是用作程序员的工具，作为构思算法的辅助工具，而不是完全的数据存储工具。这些数据结构的生命周期比数据库类型的结构要短的多，在程序执行期间它们才被创建，通常用它们去执行某项特殊的业务，执行完成之后，它们就会被销毁。

一、栈的基本概念

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

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

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

二、Java模拟简单的顺序栈实现

代码如下：

public class MyStack {

private int[] array;
private int maxSize;//数组的最大长度
private int top;//栈顶元素

public MyStack(int size) {
	// TODO Auto-generated constructor stub
	this.maxSize=size;
	array = new int[size];
	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() {
	return (top==-1);
}

//判断栈是否满了
public boolean ifFull() {
	return (top==maxSize-1);
}

public static void main(String[] args) {
	// TODO Auto-generated method stub
	MyStack stack=new MyStack(3);
	stack.push(1);
	stack.push(2);
	stack.push(3);
	System.out.println(stack.peek());
	while(!stack.isEmpty())
	{
		System.out.println(stack.pop());
	}
}

}

结果：

3
3
2
1

这个栈是用数组实现的，内部定义了一个数组，一个表示最大容量的值以及一个指向栈定元素的top变量。构造一个新栈，push()方法是向栈中压入元素，指向栈顶的变量top+1，使它指向原顶端数据项上面的一个位置，并在这个位置上存储一个数据。pop()方法返回top变量指向的元素，然后将top-1，便移除了数据项，top始终指向栈顶的元素。

产生的问题：
1、上面的栈实现初始化容量之后，后面是不能进行扩容的（虽然栈不是用来存储大量数据的），但后期数据量超过初始容量后需要进行自动扩容。
2、使用数组实现栈。在数组定义的时候，在栈中的数据类型也一并定义好了，不能在存储其他数据类型的数据，需要声明Object类型。
3、栈需要初始化容量，而且数组实现的栈元素是连续的，如果不进行初始化容量，需要改由链表实现。

三、增强功能版栈

对于上面出现的问题，给出以下解决方法（第三个问题在链表时在学习）：

代码如下：

public class ArrayStack {

	//存储元素的数组，声明为Object类型能存储任意类型的数据
	private Object[] elementData;
	//指向栈顶的指针
	private int top;
	//栈的总容量
	private int size;
	
	//默认构造一个容量为10的栈
	public ArrayStack() {
		// TODO Auto-generated constructor stub
		this.elementData=new Object[10];
		this.top=-1;
		this.size=10;
	}
	
	public  ArrayStack(int initialCapacity) throws IllegalAccessException {
		if(initialCapacity<0)
		{
			throw new IllegalAccessException("栈初始容量不能小于0："+initialCapacity);
		}
		this.elementData=new Object[initialCapacity];
		this.top=-1;
		this.size=initialCapacity;
	}
	
	//压入元素
	public Object push(Object item) {
		//是否需要扩容
		elementData[++top]=item;
		return item;
	}
	
	//弹出栈顶元素
	public Object pop() {
		
		Object object=peek();
		remove(top);
		return object;
	}
	
	//获取栈顶元素
	public Object peek() {
		if(top==-1)
		{
			throw new EmptyStackException();
		}
		return elementData[top];
	}
	
	//判断栈是否为空
	public boolean isEmpty() {
		return (top==-1);
	}
	
	//删除栈顶元素
	public void remove(int top) {
		//栈顶元素置为空
		elementData[top]=null;
		this.top--;
	}
	
	//判断是否需要扩容，如果需要，则扩大一倍容量返回true,不需要则返回false
	public boolean isGrow(int minCapacity) {
		
		int oldCapacity=size;
		//如果当前元素压入栈之后的总容量大于前面定义的容量，扩容
		if(minCapacity>=oldCapacity)
		{
			//定义扩容之后栈的总容量
			int newCapacity=0;
			//栈容量扩大2倍，看是否超出int类型所表示的最大范围
			if((oldCapacity<<1)-Integer.MAX_VALUE>0)
			{
				newCapacity=Integer.MAX_VALUE;
			}else {
				newCapacity=(oldCapacity<<1);//左移一位，相当于*2
			}
			this.size=newCapacity;
			int[] newArray=new int[size];
			elementData=Arrays.copyOf(elementData, size);
			return true;
		}else {
			return false;	
		}
	}
	
	@Test
	public void test() throws IllegalAccessException {
		ArrayStack stack=new ArrayStack(3);
		stack.push(1);
		stack.push(2);
	    stack.push(3);
	    stack.push("abc");
	    System.out.println(stack.peek());
	    stack.pop();
	    stack.pop();
	    stack.pop();
	    System.out.println(stack.peek());
		
	}

结果：

abc
1

四、利用栈实现字符串逆序

栈是一种先进后出的数据结构，我们可以将一个字符串分割为单个字符，push进栈，pop出栈，实现字符串的反转。
代码如下：

public void test2() {
		ArrayStack stack=new ArrayStack();
		String string="how are you";
		char[] ch=string.toCharArray();
		for (char c : ch) {
			stack.push(c);
		}
		while(!stack.isEmpty())
		{
			System.out.println(stack.pop());
		}
	}

五、总结

根据栈先进后出的特性，实现了单词的逆序，可以得出栈是一个概念上的工具，具体的实现的功能，可以由开发人员自己定义，栈提供了限制性的访问方法push()和pop(),使得程序不容易出错。
对于栈的操作，数据的入栈和出栈的时间复杂度都为O(1),也就是说栈操作所消耗的时间不依赖栈中数据项的个数，因此操作时间很短，而且栈是不需要比较和移动操作的。

六、学习参考链接

https://www.cnblogs.com/ysocean/p/7911910.html