我们在我们自己实现的动态数组中实现栈和队列
栈 (Stack)
一.定义
栈 (Stack):是一种线性结构,相比数组,栈对应的操作是数组的子集
性质:只能从一端添加元素,也只能从一端取出元素(栈是一种后进先出的数据结构 Last In Frist Out(LIFO))
栈的应用:我们使用的undo操作,程序调用的系统栈
二.栈的实现
从用户的角度来看有,支持下面这些操作,具体底层实现用户并不关心,实际的底层有多种实现方式。因此我们将Stack定义为一个接口,使用我们自己封装的动态数组去实现。
三.数组栈的时间复杂度分析(由于使用的动态数组进行实现,涉及到resize操作,对pop和Push使用均摊复杂度)
队列(Queue)
一.定义
队列(Queue):也是一种线性结构,相比数组,队列对应的操作是数组的子集
性质:只能从一端(队尾)添加元素,也只能从另一端(队首)取出元素(队列是一种先进先出的数据结构 Frist In Last Out(FIFO))
二.队列的实现(跟栈一样不需要知道底层实现,所以也实现一个接口)
三.数组队列的时间复杂度分析
四.数组队列的问题
我们可以看到出队操作:每次将队首的元素出队之后,我们都会将后面的元素往前移动,此时的时间复杂度为O(n)。
下面是删除队首元素的过程:
解决办法:当删除队首元素时我们把数据不向前移动,我们将队首使用front记录队首的状态。入队的时候使用tail记录尾部的状态
删除队首元素
五.循环队列(由于我们删除队首元素,front不断往后移,当入队的时候我们的tail也不断往后移,当tail到达capacity--1的位置时,此时就不能继续添加元素了,我们要做的就是让tail往回绕,这是循环队列的由来)
a.初始时
b.入队维护tail
c.出队维护front
当经过一系列的入队和出队操作以后,此时我们将tail最后一个不能放入了
因为我们需要将front = tail 为空,为了区分队空和队满,我们将capacity中,浪费一个空间
用front == tail 表示队列为空 tail+1==front 表示队列为满
tail+1 =front 队列为满其实是不准确的,准确的来说:是 (tail+1)%C = front 队列满,因为我们的tail会跑到我们数组的前端,靠的就是(tail+1)%C = front 来实现的看下一个tail的值是否等于front等于就是满的 C为整个容器的大小。
六.动态数组实现的循环队列的时间复杂度分析
栈的实现代码:
// 栈的接口
public interface Stack<E> {
int getSize();
boolean isEmpty();
void push(E e);
E pop();
E peak();
}
// 使用数组实现一个栈
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 array.getSize();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public void push(E e) {
array.addLast(e);
}
@Override
public E pop() {
return array.removeLast();
}
@Override
public E peak() {
return array.getLast();
}
@Override
public String toString(){
StringBuffer res = new StringBuffer();
res.append("stack: [");
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();
}
}
循环队列的实现代码:
//队列的接口:
public interface Queue<E> {
int getSize();
boolean isEmpty();
void enqueue(E e);
E dequeue();
E getFront();
}
// 使用数组实现一个队列
public class LoopQueue<E> implements Queue<E> {
private E[] data;
private int front,tail;
private int size; // 这里为了简单我们直接将size定义出来进行维护,其实可以使用front和tail进行维护,但是这里有resize操作可能没这么简单
public LoopQueue(int capacity){
data = (E[])new Object[capacity+1]; // 在实现循环队列的时候我们需要浪费掉一个空间
front = 0;
tail = 0;
size = 0;
}
public LoopQueue(){
data = (E[])new Object[10+1];
}
public int getCapacity(){
return data.length-1;
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
return front == tail;
}
@Override
public void enqueue(E e) {
if((tail+1)%data.length == front)
resize(getCapacity()*2);
data[tail] = e;
tail = (tail+1) % data.length;
size++;
}
private void resize(int newCapacity){
E[] newData = (E[])new Object[newCapacity+1];
for(int i=0; i<size; i++){
//有可能data 中的第一个元素就不是第一个元素了,由于是循环队列,数组可能会越界
newData[i] = data[(i+front) % data.length];
}
data = newData;
front = 0;
tail = size;
}
@Override
public E dequeue() {
if(isEmpty())
throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
E ret = data[front];
front = (front+1) % data.length;
size--;
if(size == 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];
}
@Override // 其实这里栈中间的元素是不能看到的,只是我们这里为了方便查看
public String toString(){
StringBuffer res = new StringBuffer();
res.append(String.format("loopQueue: size =%d, capacity=%d\n", size,getCapacity()));
res.append("loopQueue: ");
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();
}
}