栈(Stack)
- 栈也是一种线性结构
- 相比数组,栈对应的操作是数组的子集(可以视为一种特殊的数组)
- 只能从一端添加元素,也只能从一端取出元素,这一端称为栈顶
- 栈帧永远指向栈顶的元素
- 栈是一种后进先出的数据结构–Last in First out(LIFO)
栈的应用场景:编辑器的撤销操作,程序调用的系统栈(子函数的调用,栈可以用来记录子函数调用位置),…
结合数组篇的实现来完成栈的基本实现(ArrayStack):
Stack接口类:
/**
* @author ymn
* @version 1.0
* @date 2020\4\8 0008 13:54
*/
public interface Stack<T> {
//获取栈中元素的个数
int getSize();
//判断栈是否为空
boolean isEmpty();
//向栈中添加元素
void push(T e);
//删除栈顶的元素
T pop();
//返回栈顶的元素
T peek();
}
ArrayStack实现类:
/**
* @author ymn
* @version 1.0
* @date 2020\4\8 0008 14:02
*/
public class ArrayStack<T> implements Stack<T> {
private Array<T> 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();
}
//查看当前静态数组的容积,ArrayStack特有的方法
public int getCapacity(){
return array.getCapacity();
}
@Override
public void push(T e) {
array.addLast(e);
}
@Override
public T pop() {
return array.removeLast();
}
@Override
public T 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();
}
}
队列 Queue
- 队列也是一种线性结构
- 相比数组,队列对应的操作是数组的子集
- 只能从一端(队尾)添加元素,只能从另一端(队首)取出元素
- 队列是一种先进先出的数据结构–First In First Out(FIFO)
结合数组篇的实现来完成队列的基本实现:
Queue接口类:
/**
* @author ymn
* @version 1.0
* @date 2020\4\9 0009 9:57
*/
public interface Queue<T> {
//获取队列中元素的个数
int getSize();
//队列是否为空
boolean isEmpty();
//进队
void enqueue(T e);
//出队
T dequeue();
//获取队首元素
T getFront();
}
ArrayQueue实现类:
/**
* @author ymn
* @version 1.0
* @date 2020\4\9 0009 10:26
*/
public class ArrayQueue<T> implements Queue<T> {
private Array<T> 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(T e) {
array.addLast(e);
}
@Override
public T dequeue() {
return array.removeLast();
}
@Override
public T 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();
}
}
数组队列的复杂度分析:
int getSize() : O(1)
boolean isEmpty() : O(1)
T getFront() : O(1)
T dequeue () : O(n)
void enqueue(T e) : O(1)
因为数组队列的出队操作的时间复杂度是O(n)级别的,所以当数据量变大且需要进行频繁的出队操作时,使用数组队列是非常消耗性能的,所以当这种情况我们可以使用出队操作时间复杂度为O(1)的循环队列:
LoopQueue实现类:
import java.util.NoSuchElementException;
/**
* @author ymn
* @version 1.0
* @date 2020\4\9 0009 14:54
*/
public class LoopQueue<T> implements Queue<T> {
private T[] data;
//front表示队首元素,tail表示元素即将进入的位置,也就是队尾后的第一个位置
private int front,tail;
//size表示队列中的元素个数
private int size;
//有参构造方法
public LoopQueue(int capacity) {
data = (T[])new Object[capacity + 1];
front = 0;
tail = 0;
size = 0;
}
public LoopQueue() {
this(10);
}
public int getCapacity(){
return data.length - 1;
}
@Override
public int getSize() {
return size;
}
/**
* front等于tail时队列为空 (tail + 1) % 队列总长度 = front 队列为满
* @return
*/
@Override
public boolean isEmpty() {
return front == tail;
}
@Override
public void enqueue(T e) {
//(tail + 1) % 队列总长度 = front 队列为满,调用resize方法进行扩容
if((tail + 1) % data.length == front){
resize(getCapacity() * 2);
}
data[tail] = e;
tail = (tail + 1) % data.length;
size ++;
}
@Override
public T dequeue() {
//当队列为空时,抛出异常
if (isEmpty()){
throw new NoSuchElementException("Cannot dequeue from an empty queue");
}
T ret = data[front];
data[front] = null;
//维护front
front = (front + 1) % data.length;
size --;
//懒释放和不能让缩容的大小为0
if (size == getCapacity() / 4 && getCapacity() / 2 != 0){
resize(getCapacity() / 2);
}
return ret;
}
@Override
public T getFront() {
//当队列为空时,抛出异常
if (isEmpty()){
throw new NoSuchElementException("Cannot dequeue from an empty queue");
}
return data[front];
}
private void resize(int newCapacity){
//先声明一个新的泛型数组
T[] newData = (T[])new Object[newCapacity];
for (int i = 0; i < size; i ++){
//把元素放在扩容后的数组中
newData[i] = data[(i + front) % data.length];
}
data = newData;
//维护front 与 tail
front = 0;
tail = size;
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
//%d: 占位符; \n: 换行符
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();
}
}