1、栈的基本概念
栈(英语:stack)又称为堆栈或堆叠,栈作为一种数据结构,是一种只能在一端进行插入和删除
操作的特殊线性表。它按照先进后出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,
需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。栈具有记忆作用,对栈的插
入与删除操作中,不需要改变栈底指针。
栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶
(top),另一端为栈底(bottom);栈底固定,而栈顶浮动;栈中元素个数为零时称为空栈。插入一般称为
进栈(PUSH),删除则称为退栈(POP)。
由于堆叠数据结构只允许在一端进行操作,因而按照后进先出(LIFO, Last In First Out)的原理运
作。栈也称为后进先出表。
这里以羽毛球筒为例,羽毛球筒就是一个栈,刚开始羽毛球筒是空的,也就是空栈,然后我们一个
一个放入羽毛球,也就是一个一个push进栈,当我们需要使用羽毛球的时候,从筒里面拿,也就是pop
出栈,但是第一个拿到的羽毛球是我们最后放进去的。
2、Java模拟简单的顺序栈实现
package person.shw.structure;
/**
* @author Administrator
* @create 2020/3/18
* @since 1.0.0
*/
public class MyStack {
private Object[] array;
private int maxSize;
private int top;
// 初始化栈
public MyStack(int size) {
this.maxSize = size;
array = new Object[size];
top = -1;
}
// 元素入栈
public void push(Object value){
if (top < maxSize-1){
array[++top] = value;
}
}
// 元素出栈
public Object pop() {
return array[top--];
}
// 访问栈顶元素
public Object peek() {
return array[top];
}
// 判断栈是否为空
public boolean isEmpty() {
return top ==-1;
}
// 判断栈是否已满
public boolean isFull() {
return top == maxSize-1;
}
}
使用栈倒序输出字符串:
public static void main(String[] args) {
MyStack myStack = new MyStack(15);
String str = "how are you";
for (char c : str.toCharArray()) {
myStack.push(c);
}
while (!myStack.isEmpty()){
System.out.print(myStack.pop());
}
}
结果:
这个栈是用数组实现的,内部定义了一个数组,一个表示最大容量的值以及一个指向栈顶元素的
top变量。构造方法根据参数规定的容量创建一个新栈,push()方法是向栈中压入元素,指向栈顶的变量
top加一,使它指向原顶端数据项上面的一个位置,并在这个位置上存储一个数据。pop()方法返回top变
量指向的元素,然后将top变量减一,便移除了数据项。要知道 top 变量指向的始终是栈顶的元素。
产生的问题:
①、上面栈的实现初始化容量之后,后面是不能进行扩容的(虽然栈不是用来存储大量数据的),
如果说后期数据量超过初始容量之后怎么办?(自动扩容)
②、我们是用数组实现栈,在定义数组类型的时候,也就规定了存储在栈中的数据类型,那么同一
个栈能不能存储不同类型的数据呢?(声明为Object)
③、栈需要初始化容量,而且数组实现的栈元素都是连续存储的,那么能不能不初始化容量呢?
(改为由链表实现)
3、增强功能版栈
对于上面出现的问题,第一个能自动扩容,第二个能存储各种不同类型的数据,解决办法如下:
(第三个在讲链表的时候在介绍)
这个模拟的栈在JDK源码中,大家可以参考 Stack 类的实现
package person.shw.structure;
import java.util.EmptyStackException;
import java.util.Arrays;
/**
* @author Administrator
* @create 2020/3/18
* @since 1.0.0
*/
public class MyStackPlus {
private int initialCapacity;
private Object[] elelementData;
private int top;
// 默认初始化容量
public MyStackPlus() {
elelementData = new Object[10];
top = -1;
}
// 自定义初始化容量
public MyStackPlus(int initialCapacity) {
if (initialCapacity<0){
throw new IllegalArgumentException("初始化容量不小于0=>"+initialCapacity);
}
this.initialCapacity = initialCapacity;
top = -1;
elelementData = new Object[initialCapacity];
}
// 元素入栈
public Object push(Object value){
isGrow(top+1);
elelementData[++top] = value;
return value;
}
// 元素出栈
public Object pop() {
if (top ==-1){
throw new EmptyStackException();
}
Object obj = elelementData[top--];
elelementData[top] = null;
return obj;
}
// 访问栈顶元素
public Object peek() {
if (top ==-1){
throw new EmptyStackException();
}
return elelementData[top];
}
// 判断栈是否为空
public boolean isEmpty() {
return top ==-1;
}
// 判断栈是否已满
public boolean isFull() {
return top == initialCapacity-1;
}
// 是否需要扩容,如果需要,则扩大一倍并返回true,不需要则返回false
public boolean isGrow(int minCapacity){
int oldCapacity = this.initialCapacity;
// 如果当前元素压入栈之后总容量大于前面定义的容量,则需要扩容
if (oldCapacity<minCapacity){
int newCapacity = 0;
// 判断栈容量扩大两倍是否大于int的范围
if (oldCapacity<<1-Integer.MAX_VALUE>0){
newCapacity = Integer.MAX_VALUE;
}else {
newCapacity = oldCapacity<<1;
}
this.initialCapacity = newCapacity;
elelementData = Arrays.copyOf(elelementData,initialCapacity);
return true;
}else {
return false;
}
}
}
4、利用栈判断分隔符是否匹配
写过xml标签或者html标签的,我们都知道<必须和最近的>进行匹配,[ 也必须和最近的 ] 进行匹
配。
比如:<abc[123]abc>这是符号相匹配的,如果是 <abc[123>abc] 那就是不匹配的。
对于 12<a[b{c}]>,我们分析在栈中的数据:遇到匹配正确的就消除
//分隔符匹配
//遇到左边分隔符了就push进栈,遇到右边分隔符了就pop出栈,看出栈的分隔符是否和这个有分隔符匹配
@Test
public void testMatch(){
MyStackPlus stack = new MyStackPlus(3);
String str = "12<a[b{c}]>";
char[] cha = str.toCharArray();
for(char c : cha){
switch (c) {
case '{':
case '[':
case '<':
stack.push(c);
break;
case '}':
case ']':
case '>':
if(!stack.isEmpty()){
char ch = stack.pop().toString().toCharArray()[0];
if(c=='}' && ch != '{'
|| c==']' && ch != '['
|| c==')' && ch != '('){
System.out.println("Error:"+ch+"-"+c);
}
}
break;
default:
break;
}
}
}