double ended queue c with examples
Un tutorial detallat sobre la cua de Deque o de doble punt a C ++. El tutorial explica què és Deque, operacions bàsiques, implementació i aplicacions de C ++ i Java:
La cua de doble punt o simplement anomenada 'Deque' és una versió generalitzada de la cua.
La diferència entre Queue i Deque és que no segueix l'enfocament FIFO (First In, First Out). La segona característica de Deque és que podem inserir i eliminar elements dels extrems anteriors o posteriors.
=> Llegiu la sèrie de formació Easy C ++
Què aprendreu:
- Classificació de la cua de doble finalitat
- Operacions bàsiques tàctils
- i il·lustració
- i implementació
- Aplicacions
- Conclusió
- Lectura recomanada
Classificació de la cua de doble finalitat
Deque es pot classificar de la següent manera:
Entrada de tacte restringit; En restringir l'entrada, es pot fer la supressió des dels dos extrems, però la inserció només es pot fer a la part posterior de la cua.
Deque restringit a la sortida: A la cua restringida a la sortida, la inserció es pot fer des dels dos extrems, però la supressió només es fa en un extrem, és a dir, l'extrem frontal de la cua.
També podem implementar piles i cues amb deque.
Operacions bàsiques tàctils
A continuació es detallen les operacions bàsiques que es poden realitzar a deque.
- inserir frontal: Inseriu o afegiu un element a la part frontal del deque.
- insertDarrer: Inseriu o afegiu un element a la part posterior del deque.
- deleteFront: Suprimiu o traieu l'element de la part frontal de la cua.
- suprimeix l'últim: Suprimiu o traieu l'element de la part posterior de la cua.
- getFront: Recupera l’element frontal al deque.
- getLast: Recupera l'últim element de la cua.
- està buit: Comprova si el deque està buit.
- està ple: Comprova si el deque està ple.
i il·lustració
Un deque buit es representa de la següent manera:
plantilla d'informe d'execució de proves a Excel
A continuació, inserim l'element 1 a la part frontal.
Ara, inserim l'element 3 a la part posterior.
A continuació, afegim l’element 5 a la part frontal i quan s’incrementen els punts anteriors a 4.
A continuació, inserim els elements 7 a la part posterior i 9 a la part davantera. El deque es veurà com es mostra a continuació.
A continuació, traiem un element de la part frontal.
Així, veiem que quan els elements s’insereixen a la part frontal, la posició frontal es decrementa mentre s’incrementa quan s’elimina un element. Per a la part posterior, la posició s'incrementa per a la inserció i es decrementa per eliminar-la .
i implementació
Implementació 100 ++ tàctil
Podem implementar un deque a C ++ mitjançant matrius, així com una llista enllaçada. A part d'això, la Biblioteca de plantilles estàndard (STL) té una classe 'deque' que implementa totes les funcions d'aquesta estructura de dades.
A continuació es dóna la implementació de matriu del deque. Com que és una cua de doble punt, hem utilitzat matrius circulars per implementar-lo.
#include using namespace std; #define MAX_size 10 // Maximum size of array or Dequeue // Deque class class Deque { int array(MAX_size); int front; int rear; int size; public : Deque(int size) { front = -1; rear = 0; this->size = size; } // Operations on Deque: void insertfront(int key); void insertrear(int key); void deletefront(); void deleterear(); int getFront(); int getRear(); // Check if Deque is full bool isFull()front == rear+1); // Check if Deque is empty bool isEmpty(){ return (front == -1); } }; // Insert an element at front of the deque void Deque::insertfront(int key) { if (isFull()) { cout << 'Overflow!!
' << endl; return; } // If queue is initially empty,set front=rear=0; start of deque if (front == -1) { front = 0; rear = 0; } else if (front == 0) // front is first position of queue front = size - 1 ; else // decrement front 1 position front = front-1; array(front) = key ; // insert current element into Deque } // insert element at the rear end of deque void Deque ::insertrear(int key) { if (isFull()) { cout << ' Overflow!!
' << endl; return; } // If queue is initially empty,set front=rear=0; start of deque if (front == -1) { front = 0; rear = 0; } else if (rear == size-1) // rear is at last position of queue rear = 0; else // increment rear by 1 position rear = rear+1; array(rear) = key ; // insert current element into Deque } // Delete element at front of Deque void Deque ::deletefront() { if (isEmpty()) { cout << 'Queue Underflow!!
' << endl; return ; } // Deque has only one element if (front == rear) { front = -1; rear = -1; } else // back to initial position if (front == size -1) front = 0; else // remove current front value from Deque;increment front by 1 front = front+1; } // Delete element at rear end of Deque void Deque::deleterear() { if (isEmpty()) { cout << ' Underflow!!
' << endl ; return ; } // Deque has only one element if (front == rear) { front = -1; rear = -1; } else if (rear == 0) rear = size-1; else rear = rear-1; } // retrieve front element of Deque int Deque::getFront() { if (isEmpty()) { cout << ' Underflow!!
' << endl; return -1 ; } return array(front); } // retrieve rear element of Deque int Deque::getRear() { if(isEmpty() || rear < 0) { cout << ' Underflow!!
' << endl; return -1 ; } return array(rear); } //main program int main() { Deque dq(5); cout << 'Insert element 1 at rear end
'; dq.insertrear(1); cout << 'insert element 3 at rear end
'; dq.insertrear(3); cout << 'rear element of deque ' << ' ' << dq.getRear() << endl; dq.deleterear(); cout << 'After deleterear, rear = ' << dq.getRear() << endl; cout << 'inserting element 5 at front end
'; dq.insertfront(5); cout << 'front element of deque ' << ' ' << dq.getFront() << endl; dq.deletefront(); cout << 'After deletefront, front = ' << dq.getFront() << endl; return 0; } Sortida:
Inseriu l’element 1 a la part posterior
inseriu l'element 3 a l'extrem posterior
element posterior del deque 3
Després de retirar-lo, darrere = 1
inserint l’element 5 a la part frontal
element frontal del deque 5
Després de deletefront, front = 1
Preguntes i respostes de l'entrevista de consulta sql per a pdf amb experiència
Recompte de la implementació de Java
La interfície deque a Java, 'java.util.Deque' es deriva de la interfície 'java.util.Queue'. Deque es pot utilitzar com a cua (First In, First Out) o com a pila (Last In, First Out). Aquestes implementacions funcionen més ràpidament que la llista enllaçada.
A continuació es mostra la jerarquia de la interfície Deque a Java.
Hem de recordar alguns punts sobre la interfície Deque a Java:
- La implementació no és segura per a fils, ja que no hi ha sincronització externa.
- Deque no admet la simultaneïtat de diversos fils.
- Les implementacions de Deque mitjançant matrius no permeten l’ús d’elements NULL.
- Es permet que els arrays creixin segons els requisits, amb una capacitat lliure de restriccions i un suport de matriu redimensionable que són les dues característiques més importants.
A continuació es detallen els diversos mètodes compatibles amb la interfície Deque:
bons llocs web d’anime per veure animats de forma gratuïta
| No. | Mètode | Descripció |
|---|---|---|
| 7 | iterador () | Retorna un iterador del deque. |
| 1 | afegir (element) | Afegeix un element a la cua. |
| 2 | addFirst (element) | Afegeix un element al capçal / frontal. |
| 3 | addLast (element) | Afegeix un element a la cua / darrere. |
| 4 | oferta (element) | Afegeix un element a la cua; retorna un valor booleà per indicar si la inserció ha estat correcta. |
| 5 | offerFirst (element) | Afegeix un element al cap; retorna un valor booleà per indicar si la inserció ha estat correcta. |
| 6 | ofertaDarrer (element) | Afegeix un element a la cua; retorna un valor booleà per indicar si la inserció ha estat correcta. |
| 8 | descendingIterator () | Retorna un iterador que té l'ordre invers per a aquest deque. |
| 9 | empènyer (element) | Afegeix un element al cap del deque. |
| 10 | pop (element) | Elimina un element del cap del deque i el retorna. |
| 11 | removeFirst () | Elimina l'element de la capçalera del deque. |
| 12 | removeLast () | Elimina l’element de la cua del deque. |
| 13 | enquesta() | Recupera i elimina el primer element del deque (representat pel cap del deque); retorna NULL si el deque està buit. |
| 14 | pollFirst () | Recupera i elimina el primer element d’aquest deque; torna nul si aquest deque està buit. |
| 15 | pollLast () | Recupera i elimina l’últim element d’aquest deque; torna nul si aquest deque està buit. |
| 16 | ullada() | Recupera el cap (primer element del deque) de la cua representada per aquest deque; torna nul si aquest deque està buit. Nota: Aquesta operació no elimina l'element. |
| 17 | peekFirst () | Recupera el primer element d’aquest deque; torna nul si aquest deque està buit. Nota: Aquesta operació no elimina l'element. |
| 18 | peekLast () | Recupera l'últim element d'aquest deque o torna nul si aquest deque està buit. Nota: Aquesta operació no elimina l'element. |
La següent implementació de Java mostra les diverses operacions comentades anteriorment.
import java.util.*; class Main { public static void main(String() args) { Deque deque = new LinkedList (); // We can add elements to the queue in various ways deque.add(1); // add to tail deque.addFirst(3); deque.addLast(5); deque.push(7); //add to head deque.offer(9); deque.offerFirst(11); deque.offerLast(13); System.out.println('The deque : ' + deque + '
'); // Iterate through the queue elements. System.out.println('Standard Iterator'); Iterator iterator = deque.iterator(); while (iterator.hasNext()) System.out.print(' ' + iterator.next()); // Reverse order iterator Iterator reverse = deque.descendingIterator(); System.out.println('
Reverse Iterator'); while (reverse.hasNext()) System.out.print(' ' + reverse.next()); // Peek returns the head, without deleting // it from the deque System.out.println('
Peek ' + deque.peek()); System.out.println('After peek: ' + deque); // Pop returns the head, and removes it from // the deque System.out.println('
Pop ' + deque.pop()); System.out.println('After pop: ' + deque); // We can check if a specific element exists // in the deque System.out.println('
Contains element 3?: ' + deque.contains(3)); // We can remove the first / last element. deque.removeFirst(); deque.removeLast(); System.out.println('Deque after removing ' + 'first and last elements: ' + deque); } } Sortida:
I els (11, 7, 3, 1, 5, 9, 13)
Iterador estàndard
11 7 3 1 5 9 13
Iterador invers
13 9 5 1 3 7 11
Peek 11
Després de mirar: (11, 7, 3, 1, 5, 9, 13)
pop 11
Després del pop: (7, 3, 1, 5, 9, 13)
Conté l'element 3 ?: true
Desqueu després d'eliminar el primer i l'últim element: (3, 1, 5, 9)
En el programa anterior, hem utilitzat la interfície Deque de Java i hem definit un deque d’elements enters. A continuació, vam realitzar diverses operacions en aquest deque i vam mostrar els resultats d’aquestes operacions.
Aplicacions
Deque es pot utilitzar en algunes de les aplicacions següents.
# 1) Algorisme de programació: Un algoritme de planificació, 'A-steal scheduling algorithm', implementa la planificació de tasques per a diversos processadors del sistema multiprocessador. Aquesta implementació utilitza deque i el processador obté el primer element del deque per a l'execució.
# 2) Desfés la llista d'activitats: A les aplicacions de programari, tenim moltes accions. Un és “desfer”. Quan hem realitzat accions de desfer moltes vegades, totes aquestes accions s'emmagatzemen en una llista. Aquesta llista es manté com a deque per poder afegir / eliminar fàcilment entrades de qualsevol extrem.
# 3) Elimineu les entrades després d'un temps: Les aplicacions actualitzen les entrades de la seva llista, com ara les aplicacions que enumeren les entrades de valors, etc. Aquestes aplicacions eliminen les entrades al cap de temps i també insereixen entrades noves. Això es fa amb un deque.
Conclusió
Deque és una cua de doble extrem que ens permet afegir / eliminar elements dels dos extrems, és a dir, anteriors i posteriors, de la cua. Deque es pot implementar mitjançant matrius o llistes enllaçades. Tot i això, també tenim una classe de plantilles estàndard (STL) que implementa les diverses operacions del Deque.
A Java, tenim una interfície Deque que s’hereta de la interfície de cua per implementar Deque. A part de les operacions estàndard bàsiques del Deque, aquesta interfície admet diverses altres operacions que es poden realitzar a Deque.
Deque s'utilitza generalment per a aplicacions que requereixen afegir / eliminar elements dels dos extrems. També s’utilitza sobretot en la programació de processadors en sistemes multiprocessador.
=> Feu una ullada a la sèrie completa d’entrenament de C ++
Lectura recomanada
- Cua de prioritat a STL
- Què és la prova de comparació (apreneu amb exemples)
- Tutorial de Python DateTime amb exemples
- Ordenació de shell en C ++ amb exemples
- Talla l'ordre a Unix amb exemples
- Sintaxi d'ordres Unix Cat, opcions amb exemples
- Ús del cursor a MongoDB amb exemples
- Ordre Ls a Unix amb exemples