如下图所示:
在上图中我们可以看到栈是一种后进先出的数据结构,也就是 Last In First Out(LIFO) ,我们经常看到有 LIFO 找个单词的时候,就是说这是一种后进先出的数据结构,在计算机的世界里,栈拥有着不可思议的作用,接下来我们就来聊一聊,栈的应用。
栈在我们计算机的世界里,都有哪些操作呢?不管我们是用开发工具,还是文本编辑,我们都会用一个很常用的操作 (undo操作) ,也就是我们常用的 撤销,当我们打字打快了,打错了,我们只需要按住ctrl + z
,就可以将我们输入的文字撤销掉,那么栈是如何在撤销中工作的,比如我们想打我爱我的祖国
,这几个字,但是我们打完 我爱我的
,准备打祖国的时候,不小心打成了 一起
,于是我们就可以进行 撤销操作,将我们的 一起
,进行出栈操作,然后在将 祖国
添加到我们的栈里面,这样就完成了一次栈在撤销中的工作。
比如我有下面一段代码:
public static void A(){
System.out.println("A start");
B();
System.out.println("A end");
}
public static void B(){
System.out.println("B start");
C();
System.out.println("B end");
}
public static void C(){
System.out.println("C end");
}
首先我们会先进入 方法 A(),打印输出语句 A start
,将方法 A(),作为第一个栈,进行入栈操作,放入我们的系统栈中,然后进入方法 B(),打印输出语句 B start
,将方法 B(),作为第二个栈进行入栈操作,再进入方法 C(),打印我们的 C end
,到这里入栈操作已经完成了,我们就会从我们的栈里面去取我们刚才入栈的方法,因为 B() 方法是最后一个入栈的,遵循栈 先进后出 的原则,首先我们取出 B() 方法,进行 出栈操作,打印输出语句 B end
,最好我们取出A() 方法,进行 出栈操作,打印输出语句 A end
,以上整个就是我们程序调用系统栈的操作,我们来看下打印结果:
A start
B start
C end
B end
A end
执行流程如下图所示:
如果能够合理的运行栈,会对我们的程序起很好的作用,还有一些栈的应用,比如 递归算法
这里我们关于数组部分,可以查看上一篇:动态数组
首先我们需要以下几个栈元素:
int getSize(); // 获取栈的元素多少
boolean isEmpty(); //查看栈是否为空
void push(E e); //添加栈元素
E pop(); //出栈
E peek(); //查看栈顶元素是多少
具体方法实现:
自定义数组类:
public class Array<E> {
private E[] data;
private int size;
// 构造函数,传入数组的容量capacity构造Array
public Array(int capacity){
data = (E[])new Object[capacity];
size = 0;
}
// 无参数的构造函数,默认数组的容量capacity=10
public Array(){
this(10);
}
// 获取数组的容量
public int getCapacity(){
return data.length;
}
// 获取数组中的元素个数
public int getSize(){
return size;
}
// 返回数组是否为空
public boolean isEmpty(){
return size == 0;
}
// 在index索引的位置插入一个新元素e
public void add(int index, E e){
if(index < 0 || index > size)
throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");
if(size == data.length)
resize(2 * data.length);
for(int i = size - 1; i >= index ; i --)
data[i + 1] = data[i];
data[index] = e;
size ++;
}
// 向所有元素后添加一个新元素
public void addLast(E e){
add(size, e);
}
// 在所有元素前添加一个新元素
public void addFirst(E e){
add(0, e);
}
// 获取index索引位置的元素
public E get(int index){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Get failed. Index is illegal.");
return data[index];
}
public E getLast(){
return get(size - 1);
}
public E getFirst(){
return get(0);
}
// 修改index索引位置的元素为e
public void set(int index, E e){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Set failed. Index is illegal.");
data[index] = e;
}
// 查找数组中是否有元素e
public boolean contains(E e){
for(int i = 0 ; i < size ; i ++){
if(data[i].equals(e))
return true;
}
return false;
}
// 查找数组中元素e所在的索引,如果不存在元素e,则返回-1
public int find(E e){
for(int i = 0 ; i < size ; i ++){
if(data[i].equals(e))
return i;
}
return -1;
}
// 从数组中删除index位置的元素, 返回删除的元素
public E remove(int index){
if(index < 0 || index >= size)
throw new IllegalArgumentException("Remove failed. Index is illegal.");
E ret = data[index];
for(int i = index + 1 ; i < size ; i ++)
data[i - 1] = data[i];
size --;
data[size] = null; // loitering objects != memory leak
if(size == data.length / 4 && data.length / 2 != 0)
resize(data.length / 2);
return ret;
}
// 从数组中删除第一个元素, 返回删除的元素
public E removeFirst(){
return remove(0);
}
// 从数组中删除最后一个元素, 返回删除的元素
public E removeLast(){
return remove(size - 1);
}
// 从数组中删除元素e
public void removeElement(E e){
int index = find(e);
if(index != -1)
remove(index);
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
res.append('[');
for(int i = 0 ; i < size ; i ++){
res.append(data[i]);
if(i != size - 1)
res.append(", ");
}
res.append(']');
return res.toString();
}
// 将数组空间的容量变成newCapacity大小
private void resize(int newCapacity){
E[] newData = (E[])new Object[newCapacity];
for(int i = 0 ; i < size ; i ++)
newData[i] = data[i];
data = newData;
}
}
接口类:
public interface Stack<E> {
int getSize();
boolean isEmpty();
void push(E e);
E pop();
E peek();
}
接口实现:
import com.lyy.datasty.Array;
/**
* @program: Data-Structures
* @ClassName ArrayStack
* @description:
* @author: lyy
* @create: 2019-11-20 21:52
* @Version 1.0
* 用户不能看栈中间的元素,只能看到栈顶的元素
**/
public class ArrayStack<E> implements Stack<E>{
Array<E> array;
public ArrayStack(int capacity){
array = new Array<>(capacity);
}
public ArrayStack(){
array = new Array<>();
}
@Override
public int getSize() {
return 0;
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
public int getCapacity(){
return array.getCapacity();
}
@Override
public void push(E e) {
array.addLast(e);
}
@Override
public E pop() {
return array.removeLast();
}
@Override
public E peek() {
return array.getLast();
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append("Stack:");
res.append('[');
for (int i = 0; i < array.getSize(); i++) {
res.append(array.get(i));
if(i != array.getSize() - 1)
res.append(",");
}
res.append("] top");//哪里是栈顶
return res.toString();
}
}
测试结果:
Stack: [0] top
Stack: [0, 1] top
Stack: [0, 1, 2] top
Stack: [0, 1, 2, 3] top
Stack: [0, 1, 2, 3, 4] top
Stack: [0, 1, 2, 3] top
从结果中我们可以看到,我们每循环一次就添加一条数据,这里为了好让我们知道哪一个是 栈顶,我们在最后一个添加的数据那里,加了一个 top ,最新增加的数据,就是我们的栈顶,当我们添加完成后,可以看到栈数据为:[0, 1, 2, 3, 4] top,当我们出栈一个数据后,我们就可以看到 栈顶数据 4 就没有了,以上就是对于栈实现的代码,感兴趣的小伙伴可以自己实现一遍,源码在最后我会放在 github上,有兴趣的小伙伴记得下载。
ArrayStack:
方法 | 时间复杂度 |
---|---|
void push(E e) | O(1) 均摊 |
E pop() | O(1) 均摊 |
E peek() | O(1) |
int getSize() | O(1) |
boolean isEmpty() | O(1) |
顺序存储 和 链式存储
两种方式。在队列中,新添加的一端为 队尾 ,另一端为 队首 ,当一个元素从队尾进入队列时,一直向队首移动,直到它成为移除的元素为止。这种 先进先出(FIFO) 模式,在我们生活中也随处可见,比如:我们去银行柜台取钱,我们在取钱之前就要先去取号,先做 入队操作,也就是我们队列中的在 队尾添加元素,新来的人等待排队,等待前面的人处理完,当前面取号的人在柜台处理完之后,就会叫下一个号码,这个过程就是 出队操作,只有当在我们前面的人,都处理完之后才会轮到我们。
首先我们需要以下几个栈元素:
int getSize(); // 获取队列的元素多少
boolean isEmpty(); //查看队列是否为空
void enqueue(E e); //添加队列元素
E dequeue(); //删除队列队首元素
E getFront(); //获取队首队列元素
public interface Queue<E> {
int getSize();
boolean isEmpty();
void enqueue(E e);
E dequeue();
E getFront();
}
public class ArrayQueue<E> implements Queue<E> {
private Array<E> array;
public ArrayQueue(int capacity){
array = new Array<>(capacity);
}
public ArrayQueue(){
array = new Array<>();
}
@Override
public int getSize(){
return array.getSize();
}
@Override
public boolean isEmpty(){
return array.isEmpty();
}
public int getCapacity(){
return array.getCapacity();
}
@Override
public void enqueue(E e){
array.addLast(e);
}
@Override
public E dequeue(){
return array.removeFirst();
}
@Override
public E getFront(){
return array.getFirst();
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append("Queue: ");
res.append("front [");
for(int i = 0 ; i < array.getSize() ; i ++){
res.append(array.get(i));
if(i != array.getSize() - 1)
res.append(", ");
}
res.append("] tail");
return res.toString();
}
public static void main(String[] args) {
ArrayQueue<Integer> queue = new ArrayQueue<>();
for(int i = 0 ; i < 10 ; i ++){
queue.enqueue(i);
System.out.println(queue);
if(i % 3 == 2){
queue.dequeue();
System.out.println(queue+":================="+(i % 3));
}
}
}
}
Queue: front [0] tail
Queue: front [0, 1] tail
Queue: front [0, 1, 2] tail
Queue: front [1, 2] tail:=================2
Queue: front [1, 2, 3] tail
Queue: front [1, 2, 3, 4] tail
Queue: front [1, 2, 3, 4, 5] tail
Queue: front [2, 3, 4, 5] tail:=================2
Queue: front [2, 3, 4, 5, 6] tail
Queue: front [2, 3, 4, 5, 6, 7] tail
Queue: front [2, 3, 4, 5, 6, 7, 8] tail
Queue: front [3, 4, 5, 6, 7, 8] tail:=================2
Queue: front [3, 4, 5, 6, 7, 8, 9] tail
首先我们总共是循环十次,添加到队列中,每天添加一次打印队列中的元素,如果遇到 i % 3 == 2
,我们就去除队首的元素,就是我们在结果中看到的 =================2
的位置,每次都会把最先添加(队首)的元素给删除掉,从上面的结果中可以看出,当我们每次去 queue.dequeue()
元素的时候,其实就是操作数组中的 size --
,这样对于我们队列来说效率其实是很慢的,如果删除队首元素,后面的元素就要往前移动,对应的时间复杂度就是O(n)。
方法 | 时间复杂度 |
---|---|
void enqueue(E e) | O(1) 均摊 |
E dequeue() | O(n) |
E getFront() | O(1) |
int getSize() | O(1) |
boolean isEmpty() | O(1) |
从上面的执行结果我们可以看到,对于队列的执行来说,删除队首元素,后面的元素就要往前移动,如果,有一个n个元素的队列,数组下标 0 的一端是队首,入队操作(void enqueue(E e))就是通过数组下标一个个顺序追加,不需要移动元素,但是如果删除(E dequeue())队首元素,后面的元素就要往前移动,我们可以想象一下,有一个 10000 的元素,我们从下标 0 开始添加,添加完成后,删除 队首的元素,那么我们需要移动 9999 次, 这个操作的复杂度,对于 数组队列
来说是非常耗时的一个操作。
每当我们删除队首元素,后面的元素就要往前移动,因为,我们可以使用另一种方式来实现队列,也就是我们上面提到的 链式存储,也称 循环队列,这种方式是使用 链表 实现,比如:有两个指针,front 指向队头,tail 指向对尾元素的下一个位置,元素出队时 front 往后移动,如果到了对尾则转到头部,同理入队时 tail 后移,如果到了对尾则转到头部,这样通过下标 front 出队时,就不需要移动元素了,如果当我们的 front == tail
的时候,则说明队列为空。如下图所示:
这样我们的删除操作就变成了一个O(1) 的操作,如果当我们的 tail 满了,但是 front 前面还有空间,我们可以将 tail 引入之前在 front 前面删除的下标中 ,这样我们又可以继续添加数据了,这就是循环队列的来由,我们可以把我们的数组队列看成一个 “环”,7 之后的索引是 0 ,什么时候我们的队列才会满呢?当我们的 tail + 1 = front
的时候,就说明我们的队列才算真正的满了,如下图所示:
那么,这个时候 front == tail
为空 既可以标识为空也可以用于堆满,因此我们可以用 (tail + 1) % c == front
的表示队列满了,在这里 c = 8
就是我们队列的长度,例如我们的 front 指的是 2 而我们的 tail 指的是 1 的话,那么这个队列就是满的,因为 (1+1)% 8 = 2,大家可以想象一下,我们的钟表,我们的钟表十一点钟下一个时间,我们可以叫12点也可以叫0点,之后又变成了一点两点三点以此类推,我们整个循环队列的就想钟表一样形成了一个环。
注意:在这里我们需要在 capacity 中浪费一个空间,用来判断队列是否满了,因此我们需要在用户传递队列大小的时候,进行 +1 操作,再添加一个元素空间。
首先我们需要以下几个元素:
int getSize(); // 获取队列的元素多少
boolean isEmpty(); //查看队列是否为空
void enqueue(E e); //添加队列元素
E dequeue(); //删除队列队首元素
E getFront(); //获取队首队列元素
1、接口类:
public interface Queue<E> {
int getSize();
boolean isEmpty();
void enqueue(E e);
E dequeue();
E getFront();
}
2、接口实现类:
public class LoopQueue<E> implements Queue<E> {
private E[] data;//存放的元素
private int front, tail;//两个指针
private int size;//元素个数
public LoopQueue(int capacity){
data = (E[])new Object[capacity + 1];//进行 +1 操作,用来判断队列是否满了
front = 0;
tail = 0;
size = 0;
}
public LoopQueue(){
this(10);
}
public int getCapacity(){
return data.length - 1;//获取数据长度,需要在原来的基础上 -1
}
@Override
public boolean isEmpty(){
return front == tail;//判断队列是否满了,只需要判断是否 front == tail
}
@Override
public int getSize(){
return size;
}
@Override
public void enqueue(E e){//添加元素
if((tail + 1) % data.length == front)//如果判断 (tail + 1) % c == front 成立,表示队列满了,自动扩容
resize(getCapacity() * 2);//扩容原来的两倍
data[tail] = e;
tail = (tail + 1) % data.length;
size ++;
}
@Override
public E dequeue(){//删除元素
if(isEmpty())//判断是否为空
throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
E ret = data[front];//获取队首元素
data[front] = null;//设置为null
front = (front + 1) % data.length;//设置新队首的下标位置
size --;//大小 -1
if(size == getCapacity() / 4 && getCapacity() / 2 != 0)//如果长度大小为 getCapacity() / 4 并且 getCapacity() / 2 != 0 的时候,自动缩减
resize(getCapacity() / 2);
return ret;
}
@Override
public E getFront(){//获取队首元素
if(isEmpty())
throw new IllegalArgumentException("Queue is empty.");
return data[front];
}
private void resize(int newCapacity){//扩容操作
E[] newData = (E[])new Object[newCapacity + 1];
for(int i = 0 ; i < size ; i ++)
newData[i] = data[(i + front) % data.length];
data = newData;
front = 0;
tail = size;
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append(String.format("Queue: size = %d , capacity = %d\n", size, getCapacity()));
res.append("front [");
for(int i = front ; i != tail ; i = (i + 1) % data.length){
res.append(data[i]);
if((i + 1) % data.length != tail)
res.append(", ");
}
res.append("] tail");
return res.toString();
}
public static void main(String[] args){
LoopQueue<Integer> queue = new LoopQueue<>(5);
for(int i = 0 ; i < 10 ; i ++){
queue.enqueue(i);
System.out.println(queue);
if(i % 2 == 0){
queue.dequeue();
System.out.println(queue+":================"+i % 2);
}
}
}
}
3、执行结果:
Queue: size = 1 , capacity = 5
front [0] tail
Queue: size = 0 , capacity = 5
front [] tail:================0
Queue: size = 1 , capacity = 5
front [1] tail
Queue: size = 2 , capacity = 5
front [1, 2] tail
Queue: size = 1 , capacity = 2
front [2] tail:================0
Queue: size = 2 , capacity = 2
front [2, 3] tail
Queue: size = 3 , capacity = 4
front [2, 3, 4] tail
Queue: size = 2 , capacity = 4
front [3, 4] tail:================0
Queue: size = 3 , capacity = 4
front [3, 4, 5] tail
Queue: size = 4 , capacity = 4
front [3, 4, 5, 6] tail
Queue: size = 3 , capacity = 4
front [4, 5, 6] tail:================0
Queue: size = 4 , capacity = 4
front [4, 5, 6, 7] tail
Queue: size = 5 , capacity = 8
front [4, 5, 6, 7, 8] tail
Queue: size = 4 , capacity = 8
front [5, 6, 7, 8] tail:================0
Queue: size = 5 , capacity = 8
front [5, 6, 7, 8, 9] tail
Queue:大小个数
capacity:是队列长度,可以看到自动扩容和缩减
front:队首 tail:队尾
方法 | 时间复杂度 |
---|---|
void enqueue(E e) | O(1) 均摊 |
E dequeue() | O(1) 均摊 |
E getFront() | O(1) |
int getSize() | O(1) |
boolean isEmpty() | O(1) |
测试代码:
public class Main {
// 测试使用q运行opCount个enqueueu和dequeue操作所需要的时间,单位:秒
private static double testQueue(Queue<Integer> q, int opCount){
long startTime = System.nanoTime();
Random random = new Random();
for(int i = 0 ; i < opCount ; i ++)
q.enqueue(random.nextInt(Integer.MAX_VALUE));
for(int i = 0 ; i < opCount ; i ++)
q.dequeue();
long endTime = System.nanoTime();
return (endTime - startTime) / 1000000000.0;
}
public static void main(String[] args) {
int opCount = 100000;
ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
double time1 = testQueue(arrayQueue, opCount);
System.out.println("ArrayQueue, time: " + time1 + " s");
LoopQueue<Integer> loopQueue = new LoopQueue<>();
double time2 = testQueue(loopQueue, opCount);
System.out.println("LoopQueue, time: " + time2 + " s");
}
}
执行结果:
ArrayQueue, time: 3.552273371 s
LoopQueue, time: 0.011760769 s
我们可以看到 LoopQueue 性能是远远高于 ArrayQueue 的,我们如果把数据加大 ,差异会更加明显,如果是 1000000 的话,我的新电脑是 ArrayQueue:234s
,而LoopQueue 依旧是 0.几秒
,大家可以自行测试感受下,不过就算是新电脑,在 1000000 数据下,也要等待一会才能执行完成。
到这里栈和队列就讲完了,大家文章中有改进的地方或者有什么不懂的地方,欢迎大家在下面留言,下一篇,我们将讲解数据结构中最重要一个知识点——链表,喜欢的可以关注我,我是牧小农,我喂自己带盐,学习路上你我同行,大家加油!