算法通关村第四关——理解栈手写栈（青铜）
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());
}
}
99
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
