Queue<T> yapısı, tıpkı bir banka kuyruğundaki gibi çalışır: İlk giren eleman, ilk çıkan elemandır (FIFO - First In, First Out). Elemanları arkadan Enqueue ile ekler, önden ise Dequeue ile alırsınız. Her iki işlem de sabit zaman karmaşıklığına sahiptir.Enqueue, Dequeue ve Peek İşlemleri
C#:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
var printJobs = new Queue<string>();
printJobs.Enqueue("invoice.pdf");
printJobs.Enqueue("photo.png");
printJobs.Enqueue("report.docx");
Console.WriteLine("Waiting: " + printJobs.Count);
Console.WriteLine("Next up: " + printJobs.Peek()); // look, do not remove
string job = printJobs.Dequeue(); // remove the front
Console.WriteLine("Printing " + job);
Console.WriteLine("Next up: " + printJobs.Peek());
while (printJobs.Count > 0)
{
Console.WriteLine("Printing " + printJobs.Dequeue());
}
Console.WriteLine("Waiting: " + printJobs.Count);
}
}
Çıktı:
Kod:
Waiting: 3
Next up: invoice.pdf
Printing invoice.pdf
Next up: photo.png
Printing photo.png
Printing report.docx
Waiting: 0
Peek metodu, sıradaki öğeyi henüz kuyruktan çıkarmadan kontrol etmek ve ne yapacağınıza karar vermek için kullanılırken; Dequeue işlemi öğeyi kesin olarak dışarı çıkarır. Bir kuyruğu tamamen boşaltmak için yaygın olarak kullanılan yöntem while (queue.Count > 0) döngüsüdür. Bu döngü, işlem sırasında yeni öğeler eklenmesine izin verir; ancak foreach döngüsü buna izin vermez.Boş Kuyruk Hataları ve TryDequeue Çözümü
Kuyruk boşken
Dequeue veya Peek metodlarını çağırmak InvalidOperationException hatasına yol açar. Referans tipleriyle çalışırken bile "kuyruk boşsa null döner" gibi bir durum söz konusu değildir.
C#:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
var tickets = new Queue<int>();
try
{
tickets.Dequeue();
}
catch (InvalidOperationException e)
{
Console.WriteLine("Caught " + e.GetType().Name);
}
tickets.Enqueue(41);
tickets.Enqueue(42);
int ticket;
while (tickets.TryDequeue(out ticket))
{
Console.WriteLine("Serving ticket " + ticket);
}
Console.WriteLine(tickets.TryPeek(out ticket)); // false: empty
}
}
Çıktı:
Kod:
Caught InvalidOperationException
Serving ticket 41
Serving ticket 42
False
.NET Core 2.0 ile eklenen
TryDequeue ve TryPeek metodları, eğer kuyrukta öğe varsa true döndürüp değeri out parametresiyle ayarlar; kuyruk boşsa false döndürür. Daha eski .NET Framework sürümlerinde, Dequeue çağırmadan önce Count > 0 kontrolü yapmanız gerekir.Kuyruk İçeriğini İncelemek
Sıradaki öğeleri kuyruktan çıkarmadan da üzerinden geçebilirsiniz.
foreach, ToArray ve Contains gibi yöntemler, öğeleri önden arkaya doğru görmenizi sağlar.
C#:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
var line = new Queue<string>(new[] { "Ana", "Ben", "Chloe" });
foreach (string name in line)
{
Console.Write(name + " ");
}
Console.WriteLine();
Console.WriteLine(line.Contains("Ben"));
string[] snapshot = line.ToArray();
Console.WriteLine(snapshot[0] + " is first, " + snapshot.Length + " in line");
Console.WriteLine(line.Count); // nothing was removed
}
}
Çıktı:
Kod:
Ana Ben Chloe
True
Ana is first, 3 in line
3
Kuyruklarda indeksleme yoktur; örneğin
line[1] şeklinde bir kullanım derleme hatası verir ve aradan öğe çıkaramazsınız. Eğer bu özelliklere ihtiyaç duyuyorsanız, veri yapınız aslında bir kuyruk değildir; List<T> veya LinkedList<T> kullanmanız daha uygundur. Ayrıca, diğer koleksiyonlarda olduğu gibi, bir foreach döngüsü sırasında kuyruğa eleman eklemek veya çıkarmak InvalidOperationException fırlatır.Genişlik Öncelikli Arama (BFS) ve Kuyruklar
Kuyruğun FIFO mantığı, Genişlik Öncelikli Arama (BFS) algoritmasının gereksinimleriyle birebir örtüşür: Önce bir birim uzaklıktaki tüm düğümleri, ardından iki birim uzaklıktakileri ziyaret eder ve bu şekilde devam eder. Aşağıdaki örnekte, küçük bir ağ yapısında "Ana" adlı kişiye ulaşmak için gereken minimum bağlantı sayısı hesaplanmaktadır:
C#:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
var friends = new Dictionary<string, string[]>
{
["Ana"] = new[] { "Ben", "Chloe" },
["Ben"] = new[] { "Ana", "Dev" },
["Chloe"] = new[] { "Ana", "Dev", "Eli" },
["Dev"] = new[] { "Ben", "Chloe", "Fay" },
["Eli"] = new[] { "Chloe" },
["Fay"] = new[] { "Dev" },
};
var distance = new Dictionary<string, int> { ["Ana"] = 0 };
var queue = new Queue<string>();
queue.Enqueue("Ana");
while (queue.Count > 0)
{
string person = queue.Dequeue();
foreach (string next in friends[person])
{
if (!distance.ContainsKey(next))
{
distance[next] = distance[person] + 1;
queue.Enqueue(next);
}
}
}
foreach (var pair in distance)
{
Console.WriteLine(pair.Key + ": " + pair.Value + " step(s) from Ana");
}
}
}
Çıktı:
Kod:
Ana: 0 step(s) from Ana
Ben: 1 step(s) from Ana
Chloe: 1 step(s) from Ana
Dev: 2 step(s) from Ana
Eli: 2 step(s) from Ana
Fay: 3 step(s) from Ana
Her kişi, ilk kez ulaşıldığında kuyruğa bir kez eklenir. Kuyruk, öğeleri eklendiği sırayla geri verdiği için ulaşılan ilk yol her zaman en kısa yoldur. Eğer kuyruk yerine bir Stack kullanılırsa, aynı döngü en kısa yolu bulmayan Derinlik Öncelikli Arama'ya (DFS) dönüşür.
Aynı prensip; ağaçlarda seviye sıralı dolaşım, ızgaralarda flood fill ve bağlantı tarama işlemleri için de geçerlidir: Tek bir öğeyle başlanır ve kuyruk boşalana kadar bir öğe çıkarılıp ziyaret edilmemiş komşuları kuyruğa eklenir.
Kuyruk ve Liste Karşılaştırması
Bir
List<T> yapısını Add ve RemoveAt(0) metodlarıyla kuyruk gibi kullanabilirsiniz, ancak RemoveAt(0) işlemi kalan tüm elemanların bir pozisyon kaydırılmasını gerektirir. Örneğin, 100.000 elemanlı bir listeyi bu şekilde boşaltmak yaklaşık beş milyar eleman kaydırma işlemine yol açarken, bir Queue<T> bunu sadece 100.000 sabit zamanlı adımda tamamlar. Queue<T> arka planda dairesel bir tampon (circular buffer) kullanır; dizi içindeki baş ve son indeksleri takip eder ve yalnızca kapasite dolduğunda yeniden boyutlandırma yapar.| İşlem | Queue<T> | Kuyruk olarak kullanılan List<T> |
|---|---|---|
| Arkaya eklemek | Enqueue, O(1) | Add, O(1) |
| Önden çıkarmak | Dequeue, O(1) | RemoveAt(0), O(n) |
| Öne bakmak | Peek | list[0] |
| İndeks erişimi | Yok | list[i] |
Çok Kanallı Yapılar için ConcurrentQueue
Queue<T> thread-safe (iş parçacığı güvenli) değildir. Birden fazla thread'in aynı anda öğe ekleyip aldığı durumlarda System.Collections.Concurrent kütüphanesindeki ConcurrentQueue<T> tercih edilmelidir. Bu yapı Enqueue, TryDequeue ve TryPeek metodlarına sahiptir ancak Dequeue metodu bulunmaz. Bunun sebebi, "Count kontrolü yap ve sonra Dequeue çağır" şeklindeki iki işlem arasında başka bir thread'in araya girip kuyruğu boşaltma ihtimalidir.
C#:
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
class Program
{
static void Main()
{
var events = new ConcurrentQueue<int>();
// 4 parallel iterations each add 1,000 items.
Parallel.For(0, 4, worker =>
{
for (int i = 0; i < 1000; i++) events.Enqueue(i);
});
Console.WriteLine(events.Count);
int total = 0;
int item;
while (events.TryDequeue(out item)) total++;
Console.WriteLine(total + " processed");
}
}
Çıktı:
Kod:
4000
4000 processed
ConcurrentQueue<T> yerine standart bir Queue<T> kullanılsaydı, sonuçlar zamanlamaya göre yanlış çıkabilir veya program istisna fırlatabilirdi. Eğer üretici ve tüketici thread'lerin boş dönmek yerine yeni iş gelmesini beklemesi gerekiyorsa, BlockingCollection<T> (varsayılan olarak bir ConcurrentQueue<T>'yu sarar) veya System.Threading.Channels bekleme ve tamamlanma özellikleri sunar. Standart bir koleksiyonu manuel olarak korumak için lock mekanizmaları incelenmelidir.PriorityQueue Kullanımı
Elemanların geliş sırasına göre değil, belirlenen bir önceliğe göre (örneğin en acil destek talebi veya Dijkstra algoritmasındaki en kısa yol) çıkması gerekiyorsa, .NET 6 ve sonraki sürümlerde
PriorityQueue<TElement, TPriority> sağlanmıştır. Bu yapıda, en düşük öncelik değerine sahip öğe ilk önce çıkar:
C#:
var triage = new PriorityQueue<string, int>();
triage.Enqueue("sprained ankle", 3);
triage.Enqueue("chest pain", 1);
triage.Enqueue("headache", 5);
while (triage.TryDequeue(out string patient, out int priority))
{
Console.WriteLine($"{priority}: {patient}");
}
// 1: chest pain
// 3: sprained ankle
// 5: headache
Aynı önceliğe sahip öğeler herhangi bir sırayla çıkabilir; eğer geliş sırasının korunması isteniyorsa, öncelik değerine ek olarak bir sıra numarası eklenmelidir.
Sık Karşılaşılan Hatalar
• Kontrol yapmadan
Dequeue çağırmak: Boş bir kuyruk InvalidOperationException fırlatır; bunun yerine Count > 0 kontrolü içeren bir döngü kurun veya TryDequeue kullanın.•
Peek metodunu çağırıp öğenin kuyruktan çıktığını sanmak: Sadece Dequeue öğeyi dışarı çıkarır.• Kuyruk üzerindeki
foreach döngüsü içerisinde Enqueue yapmak: Bu işlem istisna fırlatır; bunun yerine işlemi bir while döngüsüyle gerçekleştirin.• Bir
Queue<T> nesnesini farklı thread'ler arasında paylaşmak: Bunun yerine ConcurrentQueue<T> kullanın veya bir lock mekanizması uygulayın.• Büyük veri setlerinde kuyruk simülasyonu için
List.RemoveAt(0) kullanmak: Bu işlem her çağrıda O(n) karmaşıklığa sahiptir.