SDA Lucrarea 4

În acest laborator se vor implementa stive și cozi cu vectori și liste înlănțuite.

Coada

Coada este o structură de date de tip FIFO (First In First Out), care stochează o colecție de elemente în ordinea în care au fost adăugate.

Coada are următoarele proprietăți:

1. Datele sunt stocate într-o anumită ordine (se poate spune că un element este plasat înaintea sau după un alt element în structură).
2. Numărul de elemente ce poate fi stocat de structură este nelimitat sau limitat, în funcție de implementare.
3. Elementele stocate în coadă sunt de același fel.
4. Elementele pot fi adăugate doar la unul din capete și extrase doar de la celălalt - primul element inserat este primul care este extras.

Coada suportă următoarele operații de bază:

1. Interogarea numărului de elemente din coadă.
2. Verificarea dacă coada este goală.
3. Verificarea dacă coada este plină (pentru cozi limitate).
4. Adăugarea unui element în coadă (push).
5. Extragerea unui element din coadă (pop).
6. Vizualizarea unui element din coadă fără extragerea acestuia (peek).

Implementarea cozii

Deoarece coada este o particularizare a unei secvențe în care doar o parte din operații sunt expuse utilizatorului, toate implementările de secvențe pot fi utilizate pentru implementări de cozi. Totuși, deoarece STL este implementat pentru eficiență maximă, doar structurile care oferă operații în timp minim sunt expuse pentru utilizarea în cozi: std:list și std::deque. Un deque (Double-Ended Queue) este o structură de date care permite inserția și eliminarea de elemente din ambele capete în timp constant.

Clasa care implementeaza cozi în STL este std::queue, este definită în header-ul queue și folosește implicit un std::deque pentru stocarea datelor:

#include <queue>
#include <cstdio>

int main() {
    std::queue<int> myQueue;
    myQueue.push(10);
    myQueue.push(11);
    myQueue.push(12);
    printf("Stack head is: %d\n", myQueue.front);
    return 0;
}

Dacă doriți să utilizați o listă dublu înlănțuită pentru implementarea de cozi, sintaxa este următoarea:

#include <queue>
#include <list>
#include <cstdio>

int main() {
    std::queue<int, std::list<int>> myListQueue;
    myListQueue.push(10);
    myListQueue.push(11);
    myListQueue.push(12);
    printf("Stack head of my list implemnted queue is: %d\n", myListQueue.front);
    return 0;
}

Crearea unui std::queue

Pentru crearea unei cozi noi, se definește următorul constructor:

/**
 * Constructorul alocă memorie și creeaza un un nou std::queue.
 */
queue();

Exemplu:

#include <queue>
#include <cstdio>

using std::queue;

int main() {
    queue<float> myQueue;
    myQueue.push(0.1);
    printf("Queue is empty: %d\n", myQueue.empty());
    return 0;
}

Interogarea dimensiunii

Pentru interogarea dimensiunii, se definește următoarea funcție:

/**
 * Metoda intoarce numarul de elemente din coada.
 * @return numarul de elemente din coada.
 */
uint32_t size();

Exemplu:

#include <queue>
#include <cstdio>

int main() {
    std::queue<char> charQueue;
    charQueue.push('a');
    charQueue.push('b');
    charQueue.push('c');
    printf("The queue has %u elements!\n", charQueue.size());
    return 0;
}

Adăugarea unui element - push

Pentru adăugarea unui element value în coadă, se definește următoarea funcție:

/**
 * Metoda inserează elementul value în coadă.
 * @param value elementul ce trebuie adăugat.
 */
void push(T value);

Exemplu:

#include <queue>
#include <cstdio>

int main() {
    std::queue<char> charQueue;
    charQueue.push('a');
    charQueue.push('b');
    charQueue.push('c');
    printf("The queue has %u elements!\n", charQueue.size());
    return 0;
}

Eliminarea elementului din vârful cozii - pop

Pentru extragerea unui element din coadă, se definește următoarea metodă:

/**
 * Metoda elimina următorul element din coadă.
 */
void pop();

Exemplu:

#include <queue>
#include <cstdio>

int main() {
    std::queue<char> charQueue;
    charQueue.push('a');
    charQueue.push('b');
    charQueue.push('c');

    printf("Next char is: %c\n", charQueue.front());
    charQueue.pop();
    printf("Next char is: %c\n", charQueue.front());
    charQueue.pop();
    printf("Next char is: %c\n", charQueue.front());
    charQueue.pop();
    return 0;
}

Vizualizarea primului element din coadă - front

Pentru vizualizarea primului element din coadă, fără a-l extrage, se definește următoarea metodă:

/**
 * Metoda întoarce următorul element din coadă, fără a-l extrage.
 * @return următorul element din coadă
 */
T front();

Exemplu:

#include <queue>
#include <cstdio>

int main() {
    std::queue<char> charQueue;
    charQueue.push('a');
    charQueue.push('b');
    charQueue.push('c');

    printf("Next char is: %c\n", charQueue.front());
    charQueue.pop();
    printf("Next char is: %c\n", charQueue.front());
    charQueue.pop();
    printf("Next char is: %c\n", charQueue.front());
    charQueue.pop();
    return 0;
}

Stiva

Stiva este o structură de date de tip LIFO (Last In First Out), care stochează o colecție de elemente în ordinea în care au fost adăugate.

Stiva are următoarele proprietăți:

1. Datele sunt stocate într-o anumită ordine (se poate spune că un element este plasat înaintea sau după un alt element în structură).
2. Numărul de elemente ce poate fi stocat de structură este nelimitat sau limitat, în funcție de implementare.
3. Elementele stocate în stivă sunt de același fel.
4. Elementele pot fi adăugate sau extrase doar dintr-un capăt - ultimul element inserat este primul care este extras.

Stiva suportă următoarele operații de bază:

1. Interogarea numărului de elemente din stivă.
2. Verificarea dacă stiva este goală.
3. Verificarea dacă stiva este plină (pentru stive limitate).
4. Adăugarea unui element în stivă (push).
5. Extragerea unui element din stivă (pop).
6. Vizualizarea unui element din stivă fără extragerea acestuia (peek).

Implementarea stivei

În STL, clasa care implementează stiva este std::stack. Ca și coada, această clasă se folosește de o implementare concretă de secvență care poate face operațiile necesare stivei în timp constant. Clasele posibile pentru salvarea datelor unei stive sunt std::vector, std::list și std::deque. Implicit clasa folosită este std::deque.

Crearea unui obiect de tip std::stack

Pentru crearea unei stive noi, se definește următorul constructor:

/**
 * Constructorul alocă memorie și creeaza o noua stiva.
 */
stack();

Exemplu:

#include <stack>
#include <cstdio>
using std::stack;

int main() {
    stack<char> word;
    word.push('c'); 
    word.push('a');
    word.push('s');
    word.push('t');
    word.push('r');
    word.push('a');
    word.push('v');
    word.push('e');
    word.push('t');
    word.push('e');

    while(!word.empty()) {
        printf("%c", word.top());
        word.pop();
    }
    printf("\n");
    return 0;
}

Interogarea dimensiunii

Pentru interogarea dimensiunii, se definește următoarea funcție:

/**
 * Functia intoarce numarul de elemente valide din stiva specificata.
 * @param stack stiva pentru care se cere dimensinea.
 * @return numarul de elemente valide din stiva stack.
 */
unsigned arrayStackSize(struct ArrayStack * stack);

Implementarea acestei funcții se face întorcând direct valoarea câmpului aboveHead din structură.

Pentru a verifica dacă structura este goală se definește următoarea funcție:

/**
 * Functia intoarce 1 dacă stiva specificată este goală.
 * @param stack stiva pentru care se cere dimensiunea.
 * @return 1 dacă stiva este goală, 0 dacă nu
 */
int arrayStackIsEmpty(struct ArrayStack * stack);

Implementarea acestei funcții se face întorcând 1 dacă aboveHead este egal cu 0.

Pentru a verifica dacă structura este plină se definește următoarea funcție:

/**
 * Functia intoarce 1 dacă stiva specificată este plină.
 * @param stack stiva pentru care se cere dimensiunea.
 * @return 1 dacă stiva este plină, 0 dacă nu
 */
int arrayStackIsFull(struct ArrayStack * stack);

Implementarea acestei funcții se face întorcând 1 dacă aboveHead este egal cu capacity.

Adăugarea unui element - push

Pentru adăugarea unui element newChar în stivă, se definește următoarea funcție:

/**
 * Functia inserează elementul newChar în stivă.
 * @param stack stiva la care se adaugă elementul.
 * @param newChar elementul ce trebuie adăugat.
 */
void arrayStackPush(struct ArrayStack * stack, char newChar);

Adăugarea unui element în stivă se face urmând pașii de mai jos.

1. Dacă stiva este plină, se afișează un mesaj de eroare și funcția se încheie.
2. Se scrie newChar pe poziția aboveHead în array.
3. aboveHead se incrementează cu 1.

Extragerea unui element - pop

Pentru extragerea unui element din stivă, se definește următoarea funcție:

/**
 * Functia extrage următorul element din stivă.
 * @param stack stiva din care se extrage elementul.
 * @return următorul element din stivă sau 0 dacă stiva este goală.
 */
char arrayStackPop(struct ArrayStack * stack);

Extragerea unui element din stivă se face urmând pașii de mai jos.

1. Dacă stiva este goală, se afișează un mesaj de eroare și se întoarce 0.
2. Se decrementează aboveHead cu 1.
3. Se întoarce elementul de pe poziția aboveHead din array.

Vizualizarea primului element din stivă - peek

Pentru vizualizarea primului element din stivă, fără a-l extrage, se definește următoarea funcție:

/**
 * Functia întoarce următorul element din stivă, fără a-l extrage.
 * @param stack stiva din care se vizualizează elementul.
 * @return următorul element din stivă sau 0 dacă stiva este goală.
 */
char arrayStackPeek(struct ArrayStack * stack);

Vizualizarea unui element din stivă se face urmând pașii de mai jos.

1. Dacă stivă este goală, se afișează un mesaj de eroare și se întoarce 0.
2. Se întoarce valoarea de pe poziția aboveHead - 1 din array.

Ștergerea unui ArrayStack

Pentru ștergerea unui ArrayStack se definește următoarea funcție.

/**
 * Functia dezalocă memoria folosită de stiva specificată.
 * @param stack stiva care trebuie ștearsă.
 */
void deleteArrayStack(struct ArrayStack * stack);

Ștergerea unui ArrayStack se realizează felul următor:

1. Se dezalocă memoria utilizată de array.
2. Se dezalocă memoria alocată pentru structura de tip struct ArrayStack.