数据结构学习笔记-栈（JAVA）

栈是限制在表的一端，进行插入和删除操作的线性表，栈是后进先出
栈的操作：
构造栈
销毁栈
清空栈
计算栈长度
取栈顶元素
元素压栈
元素弹栈
代码：
package com.alg.stack;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
// 栈是限制在表的一端，进行插入和删除操作的线性表，栈是后进先出
//栈的操作：构造栈 销毁栈 清空栈 计算栈长度 取栈顶元素 元素压栈 元素弹栈
// Iterable实现这个可以使用for(T t:stack)循环
public class Stack<T> implements Iterable<T>
{
// 统计数组内保存的元素数量
private int elementCount;
// 保存数据的数组
protected Object[] elementData = null;
// 数组的每次增长幅度
protected int capacityIncrement;
// 默认数组大小
private static final int DEFAULT_SIZE = 10;
// 操作数
private int modCount;
public Stack()
{
this(DEFAULT_SIZE, 0);
}
public Stack(int capacity)
{
this(capacity, 0);
}
public Stack(int capacity, int capacityIncrment)
{
elementData = newElementArray(capacity);
elementCount = 0;
this.capacityIncrement = capacityIncrment;
}
// 取栈顶元素
@SuppressWarnings("unchecked")
public T peek()
{
return (T) elementData[elementCount - 1];
}
// 出栈
@SuppressWarnings("unchecked")
public T pop()
{
final int index = --elementCount;
T t = (T) elementData[index];
elementData[index] = null;
modCount++;
return t;
}
// 入栈
public void push(T object)
{
// 栈满，增加栈容量
if (elementCount == elementData.length)
{
growByOne();
}
elementData[elementCount++] = object;
modCount++;
}
// 清空栈
public void clear()
{
for (int i = 0; i < elementCount; i++)
{
elementData = null;
}
modCount++;
elementCount = 0;
}
@SuppressWarnings( {"unused", "unchecked"})
private T[] newElementArray(int size)
{
return (T[]) new Object[size];
}
// 如果从节省空间角度考虑capacityIncrement最好设置
private void growByOne()
{
int adding = 0;
// 没有设置增量的情况
if (capacityIncrement <= 0)
{ // 如果elementData长度为0，就加1，否则就增加elementData.length的一倍
if ((adding = elementData.length) == 0)
{
adding = 1;
}
}
else
{
adding = capacityIncrement;
}
T[] newData = newElementArray(elementData.length + adding);
System.arraycopy(elementData, 0, newData, 0, elementCount);
elementData = newData;
}
public int size()
{
return elementCount;
}
@SuppressWarnings("unchecked")
public synchronized T remove(int location)
{
if (location < elementCount)
{
T result = (T) elementData[location];
elementCount--;
int size = elementCount - location;
// 把location + 1到最后整个拷贝到从location开始到最后
if (size > 0)
{
System.arraycopy(elementData, location + 1, elementData, location, size);
}
// 因为中间的某个删除的位置被覆盖，所以需要把最后一位直空
elementData[elementCount] = null;
modCount++;
return result;
}
throw new ArrayIndexOutOfBoundsException(location);
}
@SuppressWarnings("unchecked")
public synchronized T elementAt(int location)
{
if (location < elementCount)
{
return (T) elementData[location];
}
throw new ArrayIndexOutOfBoundsException(location);
}
// 有这个可以对java新特性for循环的支持
public Iterator<T> iterator()
{
return new SimpleIterator();
}
// 简单了实现迭代器
private class SimpleIterator implements Iterator<T>
{
int pos = -1;
int expectedModCount;
int lastPosition = -1;
SimpleIterator()
{
super();
expectedModCount = modCount;
}
public boolean hasNext()
{
return pos + 1 < size();
}
public T next()
{
if (expectedModCount == modCount)
{
try
{
T result = elementAt(pos + 1);
lastPosition = ++pos;
return result;
}
catch (IndexOutOfBoundsException e)
{
throw new NoSuchElementException();
}
}
throw new ConcurrentModificationException();
}
public void remove()
{
if (this.lastPosition == -1)
{
throw new IllegalStateException();
}
if (expectedModCount != modCount)
{
throw new ConcurrentModificationException();
}
try
{
Stack.this.remove(lastPosition);
}
catch (IndexOutOfBoundsException e)
{
throw new ConcurrentModificationException();
}
expectedModCount = modCount;
if (pos == lastPosition)
{
pos--;
}
lastPosition = -1;
}
}
}