Differences
This shows you the differences between two versions of the page.
|
sd-ca:laboratoare:laborator-04 [2014/03/17 09:35] emil.racec [Exerciţii] |
sd-ca:laboratoare:laborator-04 [2016/03/08 08:57] (current) darius.neatu |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== Laborator 04 - Cozi ====== | + | ====== Articol 4 - Stive ====== |
| - | Responsabili: | + | |
| - | * [[claudia.cardei@gmail.com|Claudia Cârdei]] | + | |
| - | * [[ciprianfarcasanu@gmail.com|Alex Fărcășanu]] | + | |
| ===== Obiective ===== | ===== Obiective ===== | ||
| - | În urma parcurgerii acestui laborator studentul va fi capabil să: | + | În urma parcurgerii acestui articol studentul va fi capabil să: |
| - | *înțeleagă principiul de funcționare al unei cozi | + | *înțeleagă principiul de funcționare al unei stive |
| - | *implementeze o coadă folosind un vector pentru stocarea elementelor | + | *implementeze o stivă folosind un vector pentru stocarea elementelor |
| - | *implementeze algoritmul de sortare Radix Sort | + | *transforme o expresie din forma infixată în formă postfixată |
| + | *să evalueze o expresie în formă postfixată | ||
| + | ===== Ce este o stivă? ===== | ||
| - | ===== Ce este o coadă? ===== | + | O stivă este o instanță a unui tip de date abstract ce formalizează conceptul de colecţie cu acces restricționat. Restricția respectă regula LIFO (Last In, First Out). |
| - | + | ||
| - | O coadă este o structură de date ce modelează un buffer de tip FIFO (First In, First Out). Astfel, primul element introdus în coadă va fi și primul care va fi scos din coadă. | + | |
| + | Accesul la elementele stivei se face doar prin vârful acesteia. | ||
| Operații: | Operații: | ||
| + | * //push// – adaugă un element (entitate) în stivă. Adăugarea se poate face doar la vârful stivei. | ||
| + | * //pop// – șterge un element din stivă și îl returnează. Ștergerea se poate face doar la vârful stivei. | ||
| + | * //peek// – consultă (întoarce) elementul din vârful stivei fără a efectua nicio modificare asupra acesteia. | ||
| + | * //isEmpty// – întoarce //1// dacă stiva este goală; //0// dacă are cel puțin un element | ||
| - | *//enqueue// – adaugă un element (entitate) în coadă. Adăugarea se poate face doar la sfârșitul cozii. | + | ==== Cum se implementează? ==== |
| - | *//dequeue// – șterge un element din coadă și îl returnează. Ștergerea se poate face doar la începutul cozii. | + | |
| - | *//front// – consultă (întoarce) elementul din capul cozii fără a efectua nicio modificare asupra acesteia. | + | |
| - | *//isEmpty// – întoarce //1// dacă coada este goală; //0// dacă are cel puțin un element | + | |
| - | ==== Dequeue ==== | + | O structură de date definește un set de operații și funcționalitatea acestora.\\ |
| + | **Implementarea efectivă a unei structuri de date poate fi realizată în diverse moduri, cât timp funcționalitatea este păstrată.** | ||
| - | ** Dequeue ** (sau coadă cu dublu access) este o structură de tip coadă în care însă accesul (introducere / extragere de elemente) se poate realiza "prin ambele capete". De cele mai multe ori sunt implementate folosind liste dublu înlănţuite (vor fi studiate în cadrul [[http://elf.cs.pub.ro/sd/wiki/laboratoare/laborator-01|laboratorului 5]]). Dintr-un anume punct de vedere, se poate considera că atât stiva cât şi coada clasică sunt specializări ale tipului abstract **dequeue** întrucât ambele se pot implementa folosind dequeue (şi restrângând operaţiile ce se realizează asupra sa). | + | O stivă poate fi implementată cu ajutorul unui **vector** sau cu **liste înlănțuite**. |
| + | O **listă înlănțuită** este o structură de date folosită pentru a stoca un set de elemente folosind zone de memorie discontinue. Listele vor fi studiate în cadrul [[http://ocw.cs.pub.ro/courses/sd-ca/laboratoare/laborator-06|laboratorului 6]]. | ||
| - | ==== Priority queue ==== | + | În cadrul acestui articol, ne vom concentra asupra implementării unei stive cu ajutorul unui vector de stocare. |
| - | **Coada prioritară** reprezintă un tip de coadă în care fiecare element are asociată o anume prioritate. În aceste condiţii, operaţiile de bază asupra cozii devin: | + | ==== Implementare cu vector ==== |
| - | *//enqueue// - adaugă la coadă un element cu prioritatea specificată | + | La nivel de implementare, stiva este reprezentată printr-o clasă ce folosește (pe lângă operațile ce pot fi efectuate asupra ei) un vector de stocare (//stackArray//) de o dimensiune maximă dată (//NMAX//) și un indice ce indică vârful stivei(//topLevel//). |
| - | *//dequeue// - extrage elementul cu cea mai mare prioritate | + | |
| - | *//front// - examinează elementul cu cea mai mare prioritate fără a-l extrage din coadă | + | |
| - | ==== Cum se implementează? ==== | + | <code c++ stack.h> |
| + | #ifndef __STACK__H | ||
| + | #define __STACK__H | ||
| - | La fel ca și stivele, cozile se pot implementa cu ajutorul unui **vector** sau cu **liste înlănțuite**. | + | // Primul argument al template-ului este tipul de date T |
| + | // Al doilea argument este dimensiunea maxim a stivei N | ||
| + | template<typename T, int N> | ||
| + | class Stack { | ||
| + | public: | ||
| + | // constructor | ||
| + | Stack() { | ||
| + | // TODO: initializari | ||
| + | } | ||
| - | În cadrul acestui laborator, ne vom concentra asupra implementării unei cozi cu ajutorul unui vector de stocare. | + | // destructor |
| + | ~Stack() { | ||
| + | // TODO: eliberare resurse, daca este cazul | ||
| + | } | ||
| - | ==== Implementarea cu vector ==== | + | // operator de adaugare |
| + | void push(T x) { | ||
| + | // TODO: verificari, implementare | ||
| + | } | ||
| - | Vom avea doi indici (**head** și **tail**) ce vor reprezenta începutul, respectiv sfârșitul cozii în cadrul vectorului. Apare însă următoarea problemă din punctul de vedere al spațiului neutilizat: întotdeauna spațiul de la **0** la **head-1** va fi nefolosit, iar numărul de elemente ce pot fi stocate în coadă va scădea (având inițial N elemente ce pot fi stocate, după ce se extrage prima oară un element, mai pot fi stocate doar N-1 elemente). Vrem ca întotdeauna să putem stoca maxim N elemente. | + | // operatorul de stergere |
| + | T pop() { | ||
| + | // TODO: verificari, implementare | ||
| + | } | ||
| - | **Soluția**: vector circular. | + | // operatorul de consultare |
| - | ==== Implementarea cu vector circular ==== | + | T peek() { |
| + | // TODO: verificari, implementare | ||
| + | } | ||
| - | La nivel de implementare, coada este reprezentată printr-o clasă template ce folosește (pe lângă operațiile ce pot fi efectuate asupra ei) un vector de stocare (//queueArray//) de o dimensiune maximă specificată ca al doilea argument al template-ului (//N//), doi indici ce indică începutul (//head//) şi sfârşitul cozii (//tail//). De asemenea, se reţine şi dimensiunea curentă a cozii (//size//) pentru a putea spune când aceasta este plină sau vidă. | + | // operatorul de verificare dimensiune |
| + | int isEmpty() { | ||
| + | // TODO: implementare | ||
| + | } | ||
| + | private: | ||
| + | // vectorul de stocare | ||
| + | T stackArray[N]; | ||
| - | <code c++ queue.h> | + | // pozitia in vector a varfului stivei |
| - | template <typename T, int N> | + | int topLevel; |
| - | class Queue { | + | }; |
| - | private: | + | |
| - | int head; | + | |
| - | int tail; | + | |
| - | int size; | + | |
| - | T queueArray[N]; | + | |
| - | public: | + | #endif // __STACK__H |
| - | // Constructor | + | </code> |
| - | Queue() { | + | |
| - | // TODO: | + | |
| - | } | + | |
| - | // Destructor | + | ===== Forma poloneză inversă (formă postfixată) ===== |
| - | ~Queue() { | + | |
| - | // TODO: | + | |
| - | } | + | |
| - | // Adauga la coada | + | [[http://en.wikipedia.org/wiki/Reverse_Polish_notation|Forma poloneză inversă]] este o notație matematică în care fiecare operator urmează dupa toți operanzii săi. |
| - | void enqueue(T e) { | + | |
| - | // TODO | + | |
| - | } | + | |
| - | // Extrage din coada | + | Cel mai simplu exemplu de notație postfixată este cel pentru doi operanzi și un operator: |
| - | T dequeue() { | + | ^ 5 + 4 ^ se scrie sub forma ^ 5 4 + ^ |
| - | // TODO: | + | |
| - | } | + | |
| - | // Afla primul element | + | În cazul în care există mai multe operații, operatorul apare imediat după cel de-al doilea operand: |
| - | T front() { | + | ^ 2 + 4 - 5 ^ se scrie sub forma ^ 2 4 + 5 - ^ |
| - | // TODO: | + | |
| - | } | + | |
| - | bool isEmpty() { | + | Avantajul major al formei poloneze inverse este faptul că elimină parantezele din cadrul expresilor: |
| - | // TODO: | + | ^ 5 + (1 + 4) ^ se scrie sub forma ^ 5 1 4 + + ^ |
| - | } | + | |
| - | }; | + | |
| - | </code> | + | |
| - | ===== Radix Sort ===== | + | ==== Algoritmul de conversie a unei expresii din formă infixată în formă postfixată ==== |
| - | Radix Sort este un algoritm de sortare care ţine cont de cifre individuale ale elementelor sortate. Aceste elemente pot fi nu doar numere, ci orice altceva ce se poate reprezenta prin întregi. Majoritatea calculatoarelor digitale reprezintă datele în memorie sub formă de numere binare, astfel că procesarea cifrelor din această reprezentare se dovedeşte a fi cea mai convenabilă. Există două tipuri de astfel de sortare: LSD (least significant digit) şi MSD (most significant digit). LSD procesează reprezentările dinspre cea mai puţin semnificativă cifră spre cea mai semnificativă, iar MSD invers. | + | <code> |
| + | 1. cât timp există elemente de citit | ||
| + | 1.1 citește un element | ||
| + | 1.2 dacă elementul este un număr, afișare (se adaugă la forma | ||
| + | postfixată) | ||
| + | 1.3 dacă elementul este o paranteză stângă, adaugă-l în stivă | ||
| + | 1.4 dacă elementul este o paranteză dreaptă, extrage operatorii din | ||
| + | stivă și adaugă-i la forma postfixată până când vârful stivei | ||
| + | ajunge o paranteză stângă (care este extrasă, dar nu este | ||
| + | adăugată la forma postfixată). | ||
| - | O versiune simplă a radix sort este cea care foloseşte 10 cozi (câte una pentru fiecare cifră de la 0 la 9). Aceste cozi vor reţine la fiecare pas numerele care au cifra corespunzătoare rangului curent. După această împărţire, elementele se scot din cozi în ordinea crescătoare a indicelui cozii (de la 0 la 9), şi se reţin într-un vector (care devine noua secvenţă de sortat). | + | !!! dacă stiva s-a golit fără să fie găsită o paranteză stângă, |
| - | Exemplu: | + | înseamnă că expresia inițială avea paranteze greșite |
| + | 1.5 dacă elementul este un operator (fie el O1) | ||
| + | 1.5.1 cât timp există un alt operator în vârful stivei (fie el O2) | ||
| + | ȘI precedența lui O1 este MAI MICA SAU EGALA decât cea a lui O2, extrage O2 | ||
| + | din stivă, afișare (se adaugă la forma postfixată) | ||
| + | 1.5.2 adaugă O1 în stivă | ||
| + | 2. când nu mai există elemente de citit, extrage toate elementele rămase | ||
| + | în stivă și adaugă-le la forma postfixată (elementele trebuie să fie | ||
| + | numai operatori; dacă este extrasă o paranteză stângă expresia inițială | ||
| + | avea parantezele greșite). | ||
| + | </code> | ||
| - | Secvenţa iniţială: | + | ==== Exemplu ==== |
| - | <code>170, 45, 75, 90, 2, 24, 802, 66</code> | + | Fie expresia: |
| + | <code> | ||
| + | 1 - 7 * 2 /(3 + 5)^2^5 | ||
| + | </code> | ||
| - | Numere sunt introduse în 10 cozi (într-un vector de 10 cozi), în funcţie de cifrele de la dreapta la stânga fiecărui număr. | + | ^ Element ^ Acțiune ^ Forma postfixată ^ Stiva ^ Observaţii ^ |
| - | + | | 1 | Adaugă element la forma postfixată | 1 | | | | |
| - | Cozile pentru prima iteraţie vor fi: | + | | - | Pune elementul în stivă | 1 | - | | |
| + | | 7 | Adaugă element la forma postfixată | 1,7 | - | | | ||
| + | | * | Pune elementul în stivă | 1,7 | * \\ - | * are precedență mai mare decât - | | ||
| + | | 2 | Adaugă element la forma postfixată | 1,7,2 | * \\ - | | | ||
| + | | / | Extrage element din stivă | 1,7,2* | - | / și * au aceeași prioritate | | ||
| + | | ::: | Pune elementul în stivă | ::: | / \\ - | / are precedență mai mare decât - | | ||
| + | | ( | Pune elementul în stivă | 1,7,2* | ( \\ / \\ - | | | ||
| + | | 3 | Adaugă element la forma postfixată | 1,7,2*3 | ( \\ / \\ - | | | ||
| + | | + | Pune elementul în stivă | 1,7,2*3 | + \\ ( \\ / \\ - | | | ||
| + | | 5 | Adaugă element la forma postfixată | 1,7,2*3,5 | + \\ ( \\ / \\ - | | | ||
| + | | ) | Extrage element din stivă | 1,7,2*3,5+ | ( \\ / \\ - | Se repeta până când se întâlnește ( | | ||
| + | | ::: | repetă | ::: | / \\ - | ( a fost ignorat | | ||
| + | | %%^%% | Pune elementul în stivă | 1,7,2*3,5+ | %%^%% \\ / \\ - | %%^%% are precedență mai mare decât / | | ||
| + | | 2 | Adaugă element la forma postfixată | 1,7,2*3,5+2 | %%^%% \\ / \\ - | | | ||
| + | | %%^%% | Pune elementul în stivă | 1,7,2*3,5+2 | %%^%% \\ %%^%% \\ / \\ - | %%^%% este considerat asociativ-dreapta | | ||
| + | | 5 | Adaugă element la forma postfixată | 1,7,2*3,5+2,5 | %%^%% \\ %%^%% \\ / \\ - | | | ||
| + | | Final | Extrage toate elementele din stivă | 1,7,2*3,5+2,5%%^%%%%^%%/- | | | | ||
| + | |||
| + | ==== Algoritmul de evaluare a unei expresii în formă postfixată ==== | ||
| <code> | <code> | ||
| - | * 0: 170, 090 | + | 1. cât timp există elemente de citit |
| - | * 1: nimic | + | 1.1 citește un element |
| - | * 2: 002, 802 | + | 1.2 dacă elementul este o valoare |
| - | * 3: nimic | + | 1.2.1 pune elementul în stivă |
| - | * 4: 024 | + | altfel (elementul este un operator) |
| - | * 5: 045, 075 | + | 1.2.2 extrage 2 operanzi din stivă |
| - | * 6: 066 | + | 1.2.3 dacă nu există 2 operanzi în stivă |
| - | * 7 - 9: nimic | + | EROARE: forma postfixată nu este corectă |
| + | 1.2.4 evaluează rezultatul aplicării operatorului asupra celor doi | ||
| + | operanzi | ||
| + | 1.2.5 pune rezultatul în stivă | ||
| + | 2. dacă există o singură valoare în stivă | ||
| + | 2.1 afișează valoarea ca rezultat final al evaluării expresiei | ||
| + | altfel | ||
| + | EROARE: forma postfixată nu este corectă | ||
| </code> | </code> | ||
| - | a. Se face dequeue pe toate cozile, în ordinea crescătoare a indexului cozii, şi se pun numerele într-un vector, în ordinea astfel obţinută: | + | <hidden> |
| - | Noua secvenţă de sortat: | + | ===== Exercitii ===== |
| + | 1) [**2p**] Pornind de la header-ul definit [[http://ocw.cs.pub.ro/courses/sd-ca/laboratoare/laborator-04#implementare_cu_vector|anterior]], realizați implementarea structurii de date //stivă//. | ||
| + | *constructor și destructor | ||
| + | *[**0.5p**] metoda push | ||
| + | *[**0.5p**] metoda pop | ||
| + | *[**0.5p**] metoda peek | ||
| + | *[**0.5p**] metoda isEmpty | ||
| - | <code>170, 090, 002, 802, 024, 045, 075, 066</code> | + | 2) [**5p**] Implementați conversia unei expresii din formă infixată în formă postfixată. (Pentru simplitate puteți considera că numerele conțin o singură cifră). |
| - | b. A doua iteraţie: | + | 3) [**5p**] Implementați evaluarea unei expresii în formă postfixată. (Pentru simplitate puteți considera că numerele conțin o singură cifră). |
| - | Cozi: | ||
| - | <code> | ||
| - | * 0: 002, 802 | ||
| - | * 1: nimic | ||
| - | * 2: 024 | ||
| - | * 3: nimic | ||
| - | * 4: 045 | ||
| - | * 5: nimic | ||
| - | * 6: 066 | ||
| - | * 7: 170, 075 | ||
| - | * 8: nimic | ||
| - | * 9: 090 | ||
| - | </code> | ||
| - | Noua secvenţă: | ||
| - | <code>002, 802, 024, 045, 066, 170, 075, 090</code> | + | 4) [**2p**] Verificati daca un sir format doar din paranteze rotunde este valid. |
| - | c. A treia iteraţie: | ||
| - | Cozi: | + | 1) [**3p**] Pornind de la header-ul definit [[http://ocw.cs.pub.ro/courses/sd-ca/laboratoare/laborator-03#implementare_cu_vector|anterior]], realizați implementarea structurii de date //stivă//. |
| + | *constructor și destructor | ||
| + | *[**1p**] metoda push | ||
| + | *[**1p**] metoda pop | ||
| + | *[**0.5p**] metoda peek | ||
| + | *[**0.5p**] metoda isEmpty | ||
| - | <code> | + | 2) [**2p**] Implementați evaluarea unei expresii în formă postfixată. (Pentru simplitate puteți considera că numerele conțin o singură cifră). |
| - | * 0: 002, 024, 045, 066, 075, 090 | + | |
| - | * 1: 170 | + | |
| - | * 2 - 7: nimic | + | |
| - | * 8: 802 | + | |
| - | * 9: nimic | + | |
| - | </code> | + | |
| - | Noua secvenţă: | + | 2) [**2p**] Verificati daca un sir format doar din paranteze rotunde este valid. |
| - | <code>002, 024, 045, 066, 075, 090, 170, 802 (sortată) </code> | + | 2) [**2p**] Determinați dacă un șir format din caracterele ''('', ''['', '')'', '']'' este corect parantezat. |
| - | ===== Exerciţii ===== | + | 2) [**2p**] Implementaţi evaluarea unei expresii în formă infixată care este complet parantezată. (Pentru simplitate puteți considera că numerele conțin o singură cifră). |
| - | 1) [**3p**] Pornind de la header-ul definit [[http://ocw.cs.pub.ro/courses/sd-ca/laboratoare/laborator-04#implementarea_cu_vector_circular|anterior]] realizați implementarea structurii de date //coadă//. | + | 2) [**2p**] Realizaţi conversia unui număr din baza 10 în baza 2. |
| - | * constructor și destructor | + | |
| - | * [**1p**] metoda enqueue | + | |
| - | * [**1p**] metoda dequeue | + | |
| - | * [**0.5p**] metoda front | + | |
| - | * [**0.5p**] metoda isEmpty | + | |
| - | * | + | |
| - | 2) [**3p**] Implementaţi Radix Sort (sortare descrescătoare). | + | |
| - | 3) [**2p**] Verificaţi dacă un număr este palindrom folosind o stivă şi o coadă. | + | 3) [**3p**] Implementați conversia unei expresii din formă infixată în formă postfixată. (Pentru simplitate puteți considera că numerele conțin o singură cifră). |
| - | <hidden> | + | 3) [**3p**] Implementaţi evaluarea unei expresii în formă infixată care nu este complet parantezată. (Pentru simplitate puteți considera că numerele conțin o singură cifră). |
| - | 1) [**3p**] Pornind de la header-ul definit [[http://ocw.cs.pub.ro/courses/sd-ca/laboratoare/laborator-04#implementarea_cu_vector_circular|anterior]] realizați implementarea structurii de date //coadă//. | + | |
| - | * constructor și destructor | + | |
| - | * [**1p**] metoda enqueue | + | |
| - | * [**1p**] metoda dequeue | + | |
| - | * [**0.5p**] metoda front | + | |
| - | * [**0.5p**] metoda isEmpty | + | |
| - | 2) [**3p**] Implementaţi Radix Sort (sortare crescătoare). | + | |
| - | 2) [**3p**] Implementaţi Radix Sort (sortare descrescătoare). | + | 3) [**3p**] Implementaţi problema Turnurilor din Hanoi folosind stive explicit. |
| - | 3) [**2p**] Implementaţi o stivă folosind două cozi. | + | Problema Turnurilor din Hanoi: |
| - | 3) [**2p**] Implementați o coadă folosind două stive. | + | Jocul este format din trei tije și un număr variabil de discuri, de diferite mărimi, care pot fi poziționate pe oricare din cele trei tije. Jocul începe având discurile așezate în stivă pe prima tijă, în ordinea mărimii lor, astfel încât să formeze un turn. Scopul jocului este acela de a muta întreaga stivă de pe o tijă pe alta, respectând următoarele reguli: |
| - | 3) [**2p**] Verificaţi dacă un număr este palindrom folosind un deque. | + | * Doar un singur disc poate fi mutat, la un moment dat. |
| - | + | * Fiecare mutare constă în luarea celui mai de sus disc de pe o tija și glisarea lui pe o altă tijă, chiar și deasupra altor discuri care sunt deja prezente pe acea tijă. | |
| - | 3) [**2p**] Implementaţi o coadă folosind două stive. | + | * Un disc mai mare nu poate fi poziționat deasupra unui disc mai mic. |
| </hidden> | </hidden> | ||
| ===== Interviu ===== | ===== Interviu ===== | ||
| - | Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul laboratorului. | + | Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul cursului. |
| - | - Implementaţi operaţiile elementare ale unei stive folosind două cozi . Problema admite două versiuni: una în care operaţia **pop** este eficientă, iar cealaltă în care operaţia **push** este eficientă. | + | |
| - | - Implementaţi operaţiile elementare ale unei cozi folosind două stive. | + | |
| - | - Presupunând că avem o coadă ce conţine un număr mare de elemente, coada neputând fi ţinută în memorie. Prezentaţi o modalitate de a implementa operaţiile **enqueue** şi **dequeue**. | + | |
| - | - Să se implementeze o coadă ce are şi operaţia **findmax**, pe lângă operaţiile **enqueue** şi **dequeue**. **Findmax** trebuie să returneze cea mai mare valoare aflată în coadă la momentul respectiv. Oferiţi o implementare eficientă. | + | |
| - | - Cum s-ar implementa o stivă folosind o coadă de priorităţi? | + | |
| - | - De câte cozi este nevoie ca să se poată implementa o coadă de priorităţi? | + | |
| - | + | - Implementați, folosind un singur vector, 3 stive | |
| + | - Scrieți un program cu ajutorul căruia să sortați o stivă. Nu aveți acces decât la operațiile push(), pop(), top() și isEmpty() | ||
| + | - Adăugaţi structurii de stivă o nouă funcţie numită min, funcţie care returnează cel mai mic element. Push, pop şi min trebuie să aibă complexitate O(1) | ||
| + | - Descrieți cum este folosită stiva sistemului în cazul transmiterii parametrilor apelului unei funcții | ||
| ===== Resurse ===== | ===== Resurse ===== | ||
| + | [1] [[http://www.cplusplus.com | C++ Reference]] | ||
| - | [1] - [[http://www.cs.usfca.edu/~galles/visualization/QueueArray.html | Array Queue Visualization]] | + | [2] [[http://www.cs.usfca.edu/~galles/visualization/StackArray.html|Array Stack Visualization]] |
| - | + | ||
| - | [2] - [[http://www.cs.usfca.edu/~galles/visualization/QueueLL.html | Linked List Queue Visualization]] | + | |
| - | + | ||
| - | [3] - [[http://www.cplusplus.com/reference/stl/queue/ | Queue STL Implementation]] | + | |
| - | + | ||
| - | [4] - [[http://www.cplusplus.com/reference/stl/priority_queue/ | Priority Queue STL Implementation]] | + | |
| + | [3] [[http://www.cs.usfca.edu/~galles/visualization/StackLL.html|Linked List Stack Visualziation]] | ||
