算法通关村第四关——理解栈手写栈(青铜)
1. 栈的基础知识
1.1 栈的特征
栈和队列是比较特殊的线性表,又称之为访问受限的线性表。栈是很多表达式、符号等运算的基础,也是递归的底层实现。理论上递归能做的题目栈都可以,只是有些问题用栈会非常复杂。S栈底层实现仍然是链表或者顺序表,栈与线性表的最大区别是数据的存取的操作被限制了,其插入和删除操作只允许在线性表的一端进行。一般而言,把允许操作的一端称为栈顶(Top),不可操作的一端称为栈底Bottom),同时把插入元素的操作称为入栈(Push),删除元素的操作称为出(Pop)。若栈中没有任何元素,则称为空栈,栈的结构如下图:
学习参考链接:轻松掌握栈的基本操作
我们在洗碗的时候,先洗好的放在下面,后洗好的放在上面
反过来每次使用盘子的时候,总是先拿上面的盘子,后拿下面的盘子
如果用专业术语表示,则为:后进先出、先进后出,这就是栈的特性
1.2 栈的操作
栈的常用操作主要有:
push(E):增加一个元素E
pop():弹出元素E
peek():显示栈顶元素,但是不出栈
empty():判断栈是否为空
我们在设计自己的栈的时候,不管用数组还是链表,都要实现上面几个方法。
栈的所有操作都是基于栈顶进行的,这是它的特色。
1.3 Java中的栈
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());
}
}
下面简单说一下java中Stack类的底层原理:
Java中的Stack类是基于数组实现的,底层使用Object类型的数组存储元素。下面是Stack类的部分实现代码:
public class Stack {
private Object[] elements; // 用于存储元素的数组
private int size; // 栈的大小
public Stack() {
elements = new Object[10]; // 默认初始容量为10
size = 0;
}
public void push(Object element) {
ensureCapacity(size + 1); // 确保栈的容量足够
elements[size] = element; // 将元素添加到栈顶
size++;
}
public Object pop() {
if (size == 0) {
throw new NoSuchElementException("Stack is empty");
}
Object element = elements[size - 1]; // 弹出栈顶元素
elements[size - 1] = null; // 将栈顶元素置为null,方便GC回收
size--;
return element;
}
public Object peek() {
if (size == 0) {
throw new NoSuchElementException("Stack is empty");
}
return elements[size - 1]; // 返回栈顶元素
}
public boolean isEmpty() {
return size == 0;
}
private void ensureCapacity(int minCapacity) {
if (minCapacity > elements.length) {
int newCapacity = elements.length * 2; // 扩容为原来的两倍
elements = Arrays.copyOf(elements, newCapacity);
}
}
}
Stack类通过一个动态数组elements来存储栈中的元素。
-
在构造方法中,初始化一个大小为10的数组作为底层数据结构。
-
push()方法将元素添加到栈顶时,先调用ensureCapacity()方法确保栈的容量足够,如果不够则进行扩容。
-
然后将元素添加到数组的末尾,并增加栈的大小。
-
pop()方法弹出栈顶元素时,先检查栈是否为空,如果为空则抛出异常。
-
否则,将栈顶元素弹出并将其置为null,减小栈的大小,并返回弹出的元素。
-
peek()方法返回栈顶元素,isEmpty()方法判断栈是否为空。
底层实现的关键是数组的动态扩容。当栈的容量不够时,使用Arrays.copyOf()方法创建一个新的数组,并将原数组中的元素复制到新数组中,扩容后的容量为原来的两倍。这样可以保证栈的操作在均摊时间复杂度下进行。
2. 基于数组实现栈
再看具体内容之前,先补充一点,top有的地方指向栈顶元素,有的地方指向栈顶再往上的一个空单位,这个根据题目要求设计就好,如果是面试的时候就直接问面试官,top指向到哪里,本文采用指向栈顶空位置。
采用顺序表实现的的栈,内部以数组为基础,实现对元素的存取操作。在应用中还要注意每次入栈之前先判断栈的容量是否够用,如果不够用,可以进行扩容
入栈过程如下所示:
出栈的过程如下所示:
top先将栈顶元素去除,然后再执行top–。完整的实现代码是:
class Mystack<T> {
//实现栈的数组
private Object[] stack;
//栈顶元素
private int top;
Mystack() {
//初始容量为10
stack = new Object[10];
}
//判断是否为空
public boolean isEmpty() {
return top == 0;
}
//返回栈顶元素
public T peek() {
T t = null;
if (top > 0)
t = (T) stack[top - 1];
return t;
}
public void push(T t) {
expandCapacity(top + 1);
stack[top] = t;
top++;
}
//出栈
public T pop() {
T t = peek();
if (top > 0) {
stack[top - 1] = null;
top--;
}
return t;
}
//扩大容量
public void expandCapacity(int size) {
int len = stack.length;
if (size > len) {
size = size * 3 / 2 + 1;//每次扩大50%
stack = Arrays.copyOf(stack, size);
}
}
public static void main(String[] args) {
Mystack<String> stack = new Mystack<>();
System.out.println(stack.peek());
System.out.println(stack.isEmpty());
stack.push("java");
stack.push("is");
stack.push("beautiful");
stack.push("language");
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
System.out.println(stack.peek());
System.out.println(stack.pop());
}
}
3. 基于链表实现栈
链表实现栈的方式就是,插入和删除都在头节点进行即可
class ListStack<T> {
//定义链表
class Node<T> {
public T t;
public Node next;
}
public Node<T> head;
//构造函数初始化头指针
ListStack() {
head = null;
}
//入栈
public void push(T t) {
if (t == null) {
throw new NullPointerException("参数不能为空");
}
if (head == null) {
head = new Node<T>();
head.t = t;
head.next = null;
} else {
Node<T> temp = head;
head = new Node<>();
head.t = t;
head.next = temp;
}
}
//出栈
public T pop() {
if (head == null) {
return null;
}
T t = head.t;
head = head.next;
return t;
}
//取栈顶元素
public T peek() {
if (head == null) {
return null;
}
T t = head.t;
return t;
}
//栈空
public boolean isEmpty() {
if (head == null)
return true;
else
return false;
}
public static void main(String[] args) {
ListStack stack = new ListStack();
System.out.println(stack.isEmpty());
stack.push("Java");
stack.push("is");
stack.push("beautiful");
System.out.println(stack.peek());
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
}
}
4.使用双向链表实现栈
以LinkedList作为底层数据结构实现栈时,我们利用其特性:可以从链表的头部(或尾部)高效地插入和删除元素。
在LinkedListStack类中,我们创建了一个私有的LinkedList对象ll来存储栈中的元素。
-
push()方法用于入栈操作,我们使用LinkedList的addFirst()方法将元素添加到链表的头部,即作为栈顶元素。
-
pop()方法用于出栈操作,我们使用LinkedList的removeFirst()方法移除并返回链表的第一个元素,即栈顶元素。
-
peek()方法用于获取栈顶元素,我们首先判断链表是否为空,如果不为空,则使用getFirst()方法返回链表的第一个元素,即栈顶元素;否则返回null。
-
isEmpty()方法用于判断栈是否为空,我们直接调用LinkedList的isEmpty()方法来判断链表是否为空。
public class LinkedListStack<T> {
private LinkedList<T> ll = new LinkedList<>();
//入栈
public void push(T t) {
ll.addFirst(t);
}
//出栈
public T pop() {
return ll.removeFirst();
}
//栈顶元素
public T peek() {
T t = null;
//直接取元素会报异常,需要先判断是否为空
if (!ll.isEmpty())
t = ll.getFirst();
return t;
}
//栈空
public boolean isEmpty() {
return ll.isEmpty();
}
public static void main(String[] args) {
LinkedListStack<String> stack = new LinkedListStack();
System.out.println(stack.isEmpty());
System.out.println(stack.peek());
stack.push("java");
stack.push("is");
stack.push("beautiful");
System.out.println(stack.peek());
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
}
}