stacks queues stl
Apreneu la implementació de piles i cues a STL amb exemples.
Les piles i les cues són dos contenidors a STL que tenen una naturalesa molt bàsica. Són els contenidors més senzills que tenen àmplies aplicacions en programació de programari.
En aquest tutorial, veurem una implementació detallada d’aquests dos contenidors a STL. També revisarem les diverses operacions admeses per la pila i la cua amb exemples.
=> Mireu aquí la sèrie d'entrenament C ++ simple.
Què aprendreu:
Piles
El contenidor de pila a STL és un tipus d’adaptadors de contenidors. S'utilitza per replicar una estructura de dades de pila en C ++. El contenidor de pila és un conjunt d'elements en què els elements s'insereixen en un extrem i també se suprimeixen en el mateix extrem.
Aquest punt comú d'addició i supressió es coneix com 'Part superior de la pila'.
A continuació es mostra la representació pictòrica de la pila.
Com es mostra a la representació anterior, la pila és un contenidor en què s’afegeixen i esborren elements del mateix extrem anomenat Part superior de la pila.
Com que l’addició i la supressió es produeixen al mateix extrem, podem dir que el contenidor de pila és un tipus de treball LIFO (darrer entrada, primer sortida). Això vol dir que l'element afegit primer serà l'últim que se suprimirà.
Per implementar el contenidor de pila, hem d’incloure la capçalera al nostre programa.
#include La sintaxi de la declaració general per al contenidor de pila és:
stack stackName; Operacions de pila
A continuació, analitzem les diverses operacions que apilen contenidors als suports STL.
- empènyer : l'operació d'empenta s'utilitza per inserir un element a la pila. Aquesta operació sempre afegeix elements a la part superior de la pila.
Penseu en una pila buida de tipus enter .
A continuació, afegim l’element 1 a la pila.
A continuació, afegim l’element 3 a la pila.
Segons la representació, com a resultat d'una operació push, s'afegeix un element a la part superior de la pila. Després de cada operació d’empenta, la mida de la pila augmenta en 1.
- pop : l'operació pop s'utilitza per eliminar un element de la pila. L'element eliminat és el que apunta la part superior de la pila. Com a resultat de l’operació pop, la mida de la pila es redueix en 1.
Vegem l'aspecte de l'operació pop:
Considereu la pila mystack de la forma anterior, en la qual ja hem empès 2 elements.
Ara anomenem la funció pop (). Quan s’executa aquesta trucada, s’elimina l’element situat a la part superior de la pila i el ‘Part superior’ apunta a l’element següent, tal com es mostra a continuació.
Si tornem a trucar a pop (), l'element següent (en aquest cas 1) s'eliminarà donant lloc a una pila buida.
quin és el millor bloquejador d'elements emergents per a Chrome
- superior : Retorna l'element més alt de la pila.
- buit : Comprova si la pila està buida o no.
- mida: Retorna la mida de la pila, és a dir, el nombre d'elements de la pila.
A continuació es mostra un exemple d’implementació de Stack per entendre millor les operacions.
#include #include using namespace std; void printStack(stack stk) { while (!stk.empty()) { cout << ' ' << stk.top(); stk.pop(); } cout << '
'; } int main () { stack oddstk; oddstk.push(1); oddstk.push(3); oddstk.push(5); oddstk.push(7); oddstk.push(9); cout << 'The stack is : '; printStack(oddstk); cout << '
Size of stack: ' << oddstk.size(); cout << '
Top of stack: ' << oddstk.top(); cout << '
oddstk.pop() : '; oddstk.pop(); printStack(oddstk); cout<<'
Another pop(): '; oddstk.pop(); printStack(oddstk); return 0; } 
L'exemple anterior mostra clarament l'operació push que genera una pila. També mostra la pila després de dues operacions pop consecutives.
Així hem vist la pila i les seves operacions a STL. A més, en aquest tutorial, veurem la implementació detallada d'un altre contenidor STL senzill que és 'Cua'.
Cua
La cua és un altre contenidor a STL que també és molt senzill i útil. El contenidor de cues és una rèplica de l'estructura de dades de la cua a C ++. A diferència de la pila, al contenidor de la cua hi ha dos extrems, és a dir, frontal i posterior.
Els elements s’afegeixen a la cua de la part posterior mentre s’eliminen de la part frontal de la cua. En general, la cua utilitza el tipus d’arranjament FIFO (First in, First Out).
Per implementar un contenidor de cues en un programa, hem d’incloure una capçalera al codi.
#include La sintaxi general per a la declaració de la cua és:
cua nom_cua;
Declarem el contenidor de la cua de la següent manera:
Queue myqueue; Operacions de cua
Ara, veurem les diverses operacions admeses per la cua.
- empènyer: La funció 'push' afegeix l'element al final de la cua, és a dir, a la part posterior de la cua.
- pop: La funció 'pop' elimina el primer element de la cua, és a dir, l'element de la part davantera de la cua.
Comprenguem les funcions push i pop de la cua.
Penseu en una cua buida declarada per sobre de la cua. Ara premem un número parell 2 a la cua amb l'operació
myqueue.push (2);
Ara la cua tindrà el següent aspecte:
A continuació, afegim '4' a la cua amb la trucada 'myqueue.push (4)'.
Ara la cua es veu com es mostra a continuació:
Com es va veure més amunt, els elements s’introdueixen a la cua des de la part posterior o posterior.
Ara anem a fer una operació a la cua.
myqueue.pop ();
Com veiem, quan es diu pop (), l'element situat a la part davantera de la cua s'elimina. Això vol dir que el primer element que s’introdueix a la cua és el primer element que queda fora de la cua.
- frontal: Aquesta funció retorna una referència al primer element de la cua.
- esquena: Enrere torna una referència a l'últim element de la cua.
- buit: Comprova si la cua està buida.
- mida: Retorna la mida de la cua, és a dir, el nombre d'elements de la cua.
A continuació es mostra un programa d’exemple que mostra les operacions que utilitza el contenidor de cues.
#include #include using namespace std; void printQueue(queue myqueue) { queue secqueue = myqueue; while (!secqueue.empty()) { cout << ' ' << secqueue.front(); secqueue.pop(); } cout << '
'; } int main() { queue myqueue; myqueue.push(2); myqueue.push(4); myqueue.push(6); myqueue.push(8); cout << 'The queue myqueue is : '; printQueue(myqueue); cout << '
myqueue.size() : ' << myqueue.size(); cout << '
myqueue.front() : ' << myqueue.front(); cout << '
myqueue.back() : ' << myqueue.back(); cout << '
myqueue.pop() : '; myqueue.pop(); printQueue(myqueue); return 0; } Sortida:
La cua de la cua és: 2 4 6 8
myqueue.size (): 4
myqueue.front (): 2
myqueue.back (): 8
myqueue.pop (): 4 6 8
Com es mostra més amunt, primer declarem un contenidor de cues. A continuació, utilitzant l’operació push, hi afegim els primers quatre números parells. Després, traiem l'element de la cua i mostrem la cua canviada.
com escriure casos de prova uat
Conclusió
Amb això, hem arribat al final d’aquest tutorial sobre piles i cues. Com ja s'ha esmentat, aquests són els contenidors més senzills que tenim a STL. Una altra variació del contenidor de cues es coneix com a 'cua prioritària'.
Al nostre proper tutorial, en parlarem més sobre Priority Queue a STL.
=> Visiteu aquí per aprendre C ++ des de zero.