brief introduction
dequeue refers to a two-way queue, which can insert and obtain data from the head of the queue or from the tail of the queue.
This article will introduce how to create dequeue and some basic operations of dequeue.
Implementation of bidirectional queue
Like ordinary queue items, bidirectional queues can be inserted and deleted at the head and tail respectively, so a dequeue needs to implement these four methods:
- insertFront(): inserts data from the dequeue header
- insertLast(): insert data from the end of dequeue
- deleteFront(): deletes data from the dequeue header
- deleteLast(): deletes data from the end of dequeue
Similarly, we also need a head and a rear to point to the head and tail nodes of the queue.
In other words, the queue that implements these four methods is a two-way queue. We don't care how it is implemented internally.
Next, let's intuitively experience the insertion and deletion of dequeue:
- Insert in head
- Insert at tail
- Delete in header
- Delete at tail
Bidirectional queues can also be implemented in many ways, such as circular arrays and linked lists.
Array implementation of bidirectional queue
Because the array itself has a context, that is, knowing that head can get the data behind it and knowing that rear can also get the data in front of it.
Therefore, in the implementation of array, it is enough to store the index values of head and rear.
We only need to add methods to insert data into the header and delete data from the tail:
//Head in queue
public void insertFront(int data){
if(isFull()){
System.out.println("Queue is full");
}else{
//Insert ArrayDeque from the head
head = (head + capacity - 1) % capacity;
array[head]= data;
//If the queue is empty before insertion, point real to head
if(rear == -1 ){
rear = head;
}
}
}
//Fetch data from tail
public int deleteLast(){
int data;
if(isEmpty()){
System.out.println("Queue is empty");
return -1;
}else{
data= array[rear];
//If there is only one element, reset head and real
if(head == rear){
head= -1;
rear = -1;
}else{
rear = (rear + capacity - 1)%capacity;
}
return data;
}
}Dynamic array implementation of bidirectional queue
Dynamic array can dynamically change the size of the array. Here we use multiplication to expand the array.
Let's see how to implement the extension method:
//Because it is a circular array, you can't make a simple array copy here
private void extendQueue(){
int newCapacity= capacity*2;
int[] newArray= new int[newCapacity];
//Copy all first
System.arraycopy(array,0,newArray,0,array.length);
//If rear < head, it means that the cycle has been carried out. You need to empty the data between 0-head and copy the data to the corresponding position of the new array
if(rear < head){
for(int i=0; i< head; i++){
//Reset data of 0-head
newArray[i]= -1;
//Copy to new location
newArray[i+capacity]=array[i];
}
//Reset the position of the rear
rear = rear +capacity;
//Reset capacity and array
capacity=newCapacity;
array=newArray;
}
}Because it is a circular array, we can't make a simple array copy here. We need to judge the position of rear and head to judge whether it enters the circular structure.
If the loop structure is entered, we need to reset the corresponding field data and copy it to the new array.
The methods of inserting data to the head and deleting data to the tail are consistent with the implementation of the basic queue, which is not listed here.
Linked list implementation of bidirectional queue
What is the problem if you use linked lists to implement two-way queues?
Insert at the head and insert at the tail can quickly locate the target node. But let's consider the tail deletion.
For tail deletion, we need to find the previous node of the tail node and set this node to the rear node. This requires that we can find its previous node through the rear node.
So the basic linked list can't meet our needs. Here we need to use a two-way linked list.
public class LinkedListDeQueue {
//head node
private Node headNode;
//Real node
private Node rearNode;
class Node {
int data;
Node next;
Node prev;
//Constructor for Node
Node(int d) {
data = d;
}
}
public boolean isEmpty(){
return headNode==null;
}
//Insert from the end of the team
public void insertLast(int data){
Node newNode= new Node(data);
//Point the next of the realnode to the newly inserted node
if(rearNode !=null){
rearNode.next=newNode;
newNode.prev=rearNode;
}
rearNode=newNode;
if(headNode == null){
headNode=newNode;
}
}
//Insert from the head of the team
public void insertFront(int data){
if(headNode == null){
headNode= new Node(data);
}else{
Node newNode= new Node(data);
newNode.next= headNode;
headNode.prev= newNode;
headNode= newNode;
}
}
//Delete from team leader
public int deleteFront(){
int data;
if(isEmpty()){
System.out.println("Queue is empty");
return -1;
}else{
data=headNode.data;
headNode=headNode.next;
headNode.prev=null;
}
return data;
}
//Delete from end of queue
public int deleteLast(){
int data;
if(isEmpty()){
System.out.println("Queue is empty");
return -1;
}else{
data=rearNode.data;
rearNode=rearNode.prev;
rearNode.next=null;
}
return data;
}
}Each node in the bidirectional linked list has two pointers: next and prev. Through these two pointers, we can quickly locate their next node and the previous node.
Time complexity of bidirectional linked list
Basically, the enQueue and deQueue methods implemented in the above three methods can immediately locate the location to enter or leave the queue, so their time complexity is O(1).
Code address of this article:
This article has been included in http://www.flydean.com/13-algorithm-dequeue/
The most popular interpretation, the most profound dry goods, the most concise tutorial, and many tips you don't know are waiting for you to find!
Welcome to my official account: "those things in procedure", understand technology, know you better!