1 栈的简单介绍
栈是一种先进后出的数据结构,主要的api如下
pop:弹栈,返回并弹出栈顶元素
push:压栈,往栈里添加元素
peek:返回栈顶元素
2 通过链表实现栈
public class LinkedStack<T> implements Iterable<T>, Stack<T> {
/**
* 定义一个指向栈顶的引用
*/
private Node<T> top;
private Integer size = 0;
@Override
public void push(T t) {
// 新建一个节点指向top,新top的next指向old top
Node<T> oldTop = top;
top = new Node<>(t);
top.next = oldTop;
size ++;
}
@Override
public T peek() {
return Objects.nonNull(top)? top.data: null;
}
@Override
public T pop() {
T t = null;
if(Objects.nonNull(top)) {
// 获取top数据,然后top向后移
t = top.data;
top = top.next;
size --;
}
return t;
}
@Override
public Iterator<T> iterator() {
return new Iterator<T>() {
private Node<T> current = top;
@Override
public boolean hasNext() {
return current != null;
}
@Override
public T next() {
T t = null;
if(Objects.nonNull(current)) {
t = current.data;
current = current.next;
}
return t;
}
};
}
private class Node<T> {
T data;
Node<T> next;
public Node(T data) {
this.data = data;
}
}
@Test
public void testLinkedStack() {
LinkedStack<Integer> linkedStack = new LinkedStack<>();
for (int i = 0; i < 10; i++) {
linkedStack.push(i);
}
Iterator iterator = linkedStack.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
for (int i = 0; i < 10; i++) {
System.out.println(linkedStack.pop());
}
}
}
3 通过数组实现栈,可动态调整数组大小
public class ResizingArrayStack<T> implements Iterable<T>, Stack<T> {
/**
* 初始化一个容量为1的数组
*/
private Object[] objs = new Object[1];
private Integer size = 0;
@Override
public void push(T t) {
if (Objects.isNull(t)) {
throw new NullPointerException();
}
if (size >= objs.length) {
// 扩容
resize(objs.length * 2);
}
// size使用后+1
objs[size ++] = t;
}
@Override
public T pop() {
if (size > 0) {
Object object = objs[--size];
// gc
objs[size] = null;
if (size < objs.length / 2) {
// 缩容
resize(objs.length / 2);
}
return (T) object;
}
return null;
}
@Override
public T peek() {
if (size > 0) {
return (T) objs[size - 1];
}
return null;
}
private void resize(int max) {
Object[] temps = new Object[max];
System.arraycopy(objs, 0, temps, 0, size);
objs = temps;
}
public Integer capecity() {
return objs.length;
}
@Override
public Iterator<T> iterator() {
return new Iterator<T>() {
private Integer n = size;
@Override
public boolean hasNext() {
return n > 0;
}
@Override
public T next() {
return (T) objs[--n];
}
};
}
@Override
public void forEach(Consumer<? super T> action) {
}
@Override
public Spliterator<T> spliterator() {
return null;
}
public Boolean isEmpty() {
return size == 0;
}
@Test
public void testResizingArrayStack() {
ResizingArrayStack resizingArrayStack = new ResizingArrayStack();
for (int i = 0; i < 10; i++) {
resizingArrayStack.push(i);
System.out.println(i + "->" + resizingArrayStack.capecity());
}
for (int i = 0; i < 10; i++) {
System.out.println(resizingArrayStack.pop() + "->" + resizingArrayStack.capecity());
}
}
@Override
public String toString() {
return "ResizingArrayStack{" +
"objs=" + Arrays.toString(objs) +
'}';
}
}
输出:
0->1
1->2
2->4
3->4
4->8
5->8
6->8
7->8
8->16
9->16
9->16
8->16
7->8
6->8
5->8
4->8
3->4
2->4
1->2
0->1