栈和队列是比较特殊的线性表,又称之为访问受限的线性表。栈是很多表达式、符号等运算的基础,也是递归的底层实现。理论上递归能做的题目栈都可以,只是有些问题用栈会非常复杂。
栈底层实现仍然是链表或者顺序表,栈与线性表的最大区别是数据的存取的操作被限制了,其插入和删除操作只允许在线性表的一端进行。一般而言,把允许操作的一端称为栈顶(Top),不可操作的一端称为栈底(Bottom),同时把插入元素的操作称为入栈(Push),删除元素的操作称为出栈(Pop)。若栈中没有任何元素,则称为空栈,栈的结构如下图:
java的util中就提供了栈Stack类,使用不复杂,看一个例子就够了:
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println("栈顶元素为:" + stack.peek());
while (!stack.empty()) {
//只显示没出栈
System.out.println(stack.peek());
//出栈并且显示
System.out.println(stack.pop());
}
}
栈的常用操作主要有:
- push(E):增加一个元素E
- pop():弹出元素E
- peek():显示栈顶元素,但是不出栈
- empty():判断栈是否为空
我们在设计自己的栈的时候,不管用数组还是链表,都要实现上面几个方法。
public class MyStack<T> {
private Object[] stack;
private int pos;
public MyStack(int initSize) {
if (initSize < 1) {
throw new IllegalArgumentException("initSize 不能小于1");
}
stack = new Object[initSize];
pos = -1;
}
public MyStack() {
stack = new Object[10];
pos = -1;
}
public void push(T element) {
stack[++pos] = element;
}
public T pop() {
return (T) stack[pos--];
}
public T peek() {
return (T) stack[pos];
}
public boolean empty() {
return pos == -1;
}
}
其中pos指针永远指向当前的栈顶元素
但是,这个简单的例子中可以看出来,这个栈的容量是固定不变的,假如有11个元素呢?
这就需要做到栈的扩容
public boolean extendStack() {
//这里直接简单扩大一倍,具体可自行选择
stack = Arrays.copyOf(stack, stack.length * 2);
return stack.length > pos + 1;
}
那需要在什么时候进行扩容呢?是否就是每次添加元素的时候才会需要扩容,以此我们可以修改push的代码。
public void push(T element) {
//这里选择在满的时候再扩容,也可以选择只剩下一定容量的时候再选择扩容
if (pos == stack.length - 1) {
extendStack();
}
stack[++pos] = element;
}
这样就实现了自动扩容。
接下来,我们可以看看JDK中的Stack实现,下面就是去掉文档注释后的JDK源码。
public class Stack<E> extends Vector<E> {
public Stack() {
}
public E push(E item) {
addElement(item);
return item;
}
public synchronized E pop() {
E obj;
int len = size();
obj = peek();
removeElementAt(len - 1);
return obj;
}
public synchronized E peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
return elementAt(len - 1);
}
public boolean empty() {
return size() == 0;
}
public synchronized int search(Object o) {
int i = lastIndexOf(o);
if (i >= 0) {
return size() - i;
}
return -1;
}
}
我们以push为例,点进去看看。
public synchronized void addElement(E obj) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
}
addElement方法被synchronized包裹,可以得出他是线程安全的方法,
ensureCapacityHelper就是保障Stack的容量的一个方法,实现自动扩容,基本就是具体扩容规则的一些实现,不再深究。
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
从push源码可以看出,JDK Stack实现基本与我们自行实现的Stack基本相似,在细节上有些区别,大家可以去试试实现一下JDK中的Stack。