队列的基本操作

队列入队出队实现

队列是种先进先出的数据结构。

队列的基本操作主要是入队和出队。

数据从队尾进入队列，从队首出队列。

下面来写一个简单的队列:

public class MyQueue {

private List data;

private int pointer;

public MyQueue() {

data = new ArrayList<>();

pointer = 0;

}

public boolean isEmpty() {

return pointer >= data.size();

}

/**

* Get the front item from the queue.

*/

public int Front() {

return data.get(pointer);

}

/**

* Insert an element into the queue. Return true if the operation is successful.

*/

public boolean enQueue(int x) {

data.add(x);

return true;

}

/**

* Delete an element from the queue. Return true if the operation is successful.

*/

public boolean deQueue() {

if (isEmpty()) {

return false;

}

pointer++;

return true;

}

}

其中,pointer代表头队首第一个位置的数据。

当头部有数据出队时，对应的pointer指针会往后移动一位。

如果有数据入队，会直接加在队尾：

我们会发现，随着队首数据的数据的出队，队首指针之前的空间都会被浪费掉，而且随着使用次数变多，空间浪费会越来越高。

为了重复使用这部分空间，避免浪费，我们可以设计一个队首与队尾相连接的队列，重复利用空间。

循环队列设计

如上图所示，数据1 ~ 10依次入队，队首head在1处，队尾tail在10处，如果将1出队列,head头指针将移动到2:

此时，有一个空位，我们还可以继续入队：

这样利用空间，刚好可以把队首浪费的空间利用上。

class MyCircularQueue {

private Integer[] data; //队列数据

private Integer size; //队列大小

private Integer head = -1; //头指针

private Integer tail = -1; //尾指针

/**

* 初始化队列

*/

public MyCircularQueue(int k) {

this.data = new Integer[k];

this.size = k;

}

/**

* 入队操作

*/

public boolean enQueue(int value) {

if (isFull()) {

return false;

}

if (head == -1) {

head++;

}

tail++;

data[tail % size] = value;

return true;

}

/**

* 出队操作

*/

public boolean deQueue() {

if (isEmpty()) {

return false;

}

if (head == tail % size) {

head = -1;

tail = -1;

} else {

head++;

}

return true;

}

/**

* 获取队首元素

*/

public int Front() {

if (isEmpty()) {

return -1;

}

return data[head];

}

/**

* 获取队尾元素

*/

public int Rear() {

if (isEmpty()) {

return -1;

}

return data[tail % size];

}

/**

* 判断队列是不是为空

*/

public boolean isEmpty() {

return tail == -1 && head == -1;

}

/**

* 检查队列是不是已经满了

*/

public boolean isFull() {

return (tail % size - head) == size - 1 || (head - tail % size) == 1;

}

}

广度优先搜索(BFS)及其实现

上面我们已经实现过基本的队列已经如果优化队列，下面我们来看一个队列在 BFS(广度优先搜索)算法中的应用。

首先我们来定义结点：

@Getter

@Setter

@EqualsAndHashCode

@NoArgsConstructor

class Node implements Serializable {

private static final long serialVersionUID = 3687337665231315466L;

String value;

Collection previews; //前置结点

Collection tails; //后置结点

public Node(String value, Collection previews, Collection tails) {

this.value = value;

}

public Node(String value) {

this.value = value;

}

}

之后，我们先用队列来实现简单的BFS:

int BFS(Node root, Node target) {

Queue queue = new LinkedBlockingQueue(); // store all nodes which are waiting to be processed

int step = 0; // number of steps neeeded from root to current node

queue.add(root);

while (!queue.isEmpty()) {

step++;

int size = queue.size();

for (int i = 0; i < size; i++) {

Node cur = queue.poll();

if (cur.equals(target)) {

return step;

}

if (cur.tails != null) {

for (Node node : cur.tails) {

queue.add(node);

}

}

}

}

return -1;

}

另外，考虑到图结构中，像上面这样访问，可能会存在访问重复结点的情况，所以，我们记录下访问过的结点，访问过就直接跳过。

下面是改进算法：

/**

* 避免一个节点访问两次,单独检查访问过的结点

*

* @param root

* @param target

* @return

*/

int BFS(Node root, Node target) {

Queue queue = new LinkedBlockingQueue(); // store all nodes which are waiting to be processed

Set userd = new HashSet<>(); // node that be used

int step = 0; // number of steps neeeded from root to current node

queue.add(root);

userd.add(root);

while (!queue.isEmpty()) {

step++;

int size = queue.size();

for (int i = 0; i < size; i++) {

Node cur = queue.poll();

if (cur.equals(target)) {

return step;

}

if (cur.tails != null) {

for (Node node : cur.tails) {

if (!userd.contains(node)) {

queue.add(node);

userd.add(node);

}

}

}

}

}

return -1;

}

Stack

与队列相反，栈是种先入后出的结构。

下面我们来看下Java里面的栈基本入栈和出栈是如何实现的：

首先是入栈操作：

/**

* Pushes an item onto the top of this stack. This has exactly

* the same effect as:

*

* addElement(item)

*

* @param item the item to be pushed onto this stack.

* @return the item argument.

* @see java.util.Vector#addElement

*/

public E push(E item) {

addElement(item);

return item;

}

/**

* Adds the specified component to the end of this vector,

* increasing its size by one. The capacity of this vector is

* increased if its size becomes greater than its capacity.

*

*

This method is identical in functionality to the

* {@link #add(Object) add(E)}

* method (which is part of the {@link List} interface).

*

* @param obj the component to be added

*/

public synchronized void addElement(E obj) {

modCount++;

ensureCapacityHelper(elementCount + 1);

elementData[elementCount++] = obj;

}

入栈 操作即将数据插入数组尾部。ps:入栈之前会去进行容量检查，如果不够，会进行内部数组的扩容操作，会重新产生大容量数组，并将原来老数组拷贝到新数组，完成扩容。过程跟 ArrayList 的类似。

下面来看下出栈：

/**

* Removes the object at the top of this stack and returns that

* object as the value of this function.

*

* @return The object at the top of this stack (the last item

* of the Vector object).

* @throws EmptyStackException if this stack is empty.

*/

public synchronized E pop() {

E obj;

int len = size();

obj = peek();

removeElementAt(len - 1);

return obj;

}

public synchronized void removeElementAt(int index) {

modCount++;

if (index >= elementCount) {

throw new ArrayIndexOutOfBoundsException(index + " >= " +

elementCount);

}

else if (index < 0) {

throw new ArrayIndexOutOfBoundsException(index);

}

int j = elementCount - index - 1;

if (j > 0) {

System.arraycopy(elementData, index + 1, elementData, index, j);

}

elementCount--;

elementData[elementCount] = null; /* to let gc do its work */

}

这里，直接将数组尾部的数移除。

深度优先搜索(DFS)

首先来看DFS的简单递归实现：

/*

* 基于递归实现 DFS

*/

boolean DFS(Node cur, Node target, Set visited) {

if (cur == target) {

return true;

}

if (cur.tails == null || cur.tails.size() < 1) {

return false;

}

for (Node n : cur.tails) {

visited.add(n);

if (DFS(n, target, visited)) {

return true;

}

}

return false;

}

基于递归的实现，系统会自动帮我们生成堆栈调用，但是如果递归的深度过高的话，终将造成堆栈溢出。这时候，我们就需要自己用Stack实现这一过程：

/**

* 基于 stack

*

* @param cur

* @param target

* @return

*/

boolean DFS(Node cur, Node target) {

Set visited = new HashSet<>();

Stack stack = new Stack();

stack.push(cur);

while (!stack.isEmpty()) {

Node temp = stack.pop();

if (temp == target) {

return true;

}

for (Node n : temp.tails) {

if (!visited.contains(n)) {

visited.add(n);

stack.push(n);

}

}

}

return false;

}