Coada Queue

Clasa Queue<T> reprezintă o coadă obișnuită, care funcționează conform algoritmului FIFO ("primul venit - primul plecat").

Crearea unei cozi

Pentru a crea o coadă, se poate folosi unul dintre cei trei constructori ai săi. În primul rând, putem crea o coadă goală:

Queue<string> people = new Queue<string>();

La crearea unei cozi goale, se poate specifica capacitatea cozii:

Queue<string> people = new Queue<string>(16);

De asemenea, se poate inițializa coada cu elemente dintr-o altă colecție sau array:

var employees = new List<string> { "Tom", "Sam", "Bob" };
Queue<string> people = new Queue<string>(employees);
foreach (var person in people) Console.WriteLine(person);

Console.WriteLine(people.Count); // 3

Pentru parcurgerea cozii se poate folosi ciclul standard foreach.

Pentru a obține numărul de elemente din coadă, clasa are proprietatea Count.

Metode Queue

Clasa Queue<T> are următoarele metode importante:

void Clear(): șterge toate elementele din coadă
bool Contains(T item): returnează true dacă elementul item este prezent în coadă
T Dequeue(): extrage și returnează primul element din coadă
void Enqueue(T item): adaugă un element la sfârșitul cozii
T Peek(): returnează primul element din coadă fără a-l șterge

Să vedem aplicarea cozii în practică:


var people = new Queue<string>();

// adăugăm elemente
people.Enqueue("Tom");  // people = { Tom }
people.Enqueue("Bob");  // people = { Tom, Bob }
people.Enqueue("Sam");  // people = { Tom, Bob, Sam }

// obținem elementul din capul cozii
var firstPerson = people.Peek();
Console.WriteLine(firstPerson); // Tom

// ștergem elemente
var person1 = people.Dequeue();  // people = { Bob, Sam }
Console.WriteLine(person1); // Tom
var person2 = people.Dequeue();  // people = { Sam }
Console.WriteLine(person2); // Bob
var person3 = people.Dequeue();  // people = { }
Console.WriteLine(person3); // Sam

Este de remarcat că, dacă folosim metodele Peek sau Dequeue pentru a obține primul element dintr-o coadă goală, programul va arunca o excepție. Prin urmare, înainte de a obține un element, putem verifica numărul de elemente din coadă:

if(people.Count > 0)
{
   var person = people.Peek();
   people.Dequeue();
}

Sau putem folosi perechea de metode:

bool TryDequeue(out T result): atribuie în variabila result primul element din coadă și îl șterge, returnează true dacă coada nu este goală și elementul a fost obținut cu succes
bool TryPeek(out T result): atribuie în variabila result primul element din coadă fără a-l șterge, returnează true dacă coada nu este goală și elementul a fost obținut cu succes

Aplicarea metodelor:

var people = new Queue<string>();

// adăugăm elemente
people.Enqueue("Tom");  // people = { Tom }

// ștergem elemente
var success1 = people.TryDequeue(out var person1);  // success1 = true
if (success1) Console.WriteLine(person1); // Tom

var success2 = people.TryPeek(out var person2);  // success2 = false
if (success2) Console.WriteLine(person2);

Cozile sunt structuri des întâlnite în viața reală. De exemplu, o coadă de pacienți la medic. Să implementăm această situație:

var patients = new Queue<Person>();
patients.Enqueue(new Person("Tom"));
patients.Enqueue(new Person("Bob"));
patients.Enqueue(new Person("Sam"));

var practitioner = new Doctor();
practitioner.TakePatients(patients);

class Person
{
   public string Name { get; }
   public Person(string name) => Name = name;
}

class Doctor
{
   public void TakePatients(Queue<Person> patients)
   {
       while(patients.Count > 0)
       {
           var patient = patients.Dequeue();
           Console.WriteLine($"Consultația pacientului {patient.Name}");
       }
       Console.WriteLine("Doctorul a terminat consultațiile pacienților");
   }
}

Aici, clasa medic - clasa Doctor, în metoda TakePatients, primește o coadă de pacienți sub formă de obiecte Person. Și, cât timp există obiecte în coadă, extrage câte un obiect pe rând. Rezultatul în consolă:

Consultația pacientului Tom
Consultația pacientului Bob
Consultația pacientului Sam
Doctorul a terminat consultațiile pacienților