配列&コレクション

[C#] Queue(キュー)の使い方を初心者向けに解説

2025-01-18更新日: 2025-01-18

Queueは、C#で提供されるデータ構造の一つで、先入れ先出し(FIFO: First In, First Out)の順序で要素を管理します。

つまり、最初に追加された要素が最初に取り出されます。

Queueを使うには、System.Collections.Generic名前空間をインポートします。

要素を追加するにはEnqueue()メソッド、取り出すにはDequeue()メソッドを使用します。

Peek()メソッドを使うと、取り出さずに先頭の要素を確認できます。

Queueは、タスクの順番待ちやバッファリングなどに便利です。

目次から探す

Queueとは？基本的な概念と特徴

Queue(キュー)は、データ構造の一つで、先入れ先出し(FIFO: First In First Out)方式で要素を管理します。

これは、最初に追加された要素が最初に取り出されることを意味します。

キューは、タスクの処理やデータの流れを管理する際に非常に便利です。

例えば、プリンターのジョブ管理や、ネットワークパケットの処理など、順番に処理する必要がある場面でよく使用されます。

C#では、Queue<T>クラスを使用して、任意のデータ型の要素を格納することができます。

キューの基本的な操作には、要素の追加(Enqueue)、要素の取り出し(Dequeue)、先頭要素の確認(Peek)などがあります。

これにより、データの管理が効率的に行えるため、プログラミングにおいて非常に重要な役割を果たします。

Queueの基本的な使い方

Queueの宣言と初期化

C#でQueueを使用するには、まずSystem.Collections.Generic名前空間をインポートし、Queue<T>クラスを宣言して初期化します。

以下は、整数型のQueueを宣言し、初期化する例です。

using System.Collections.Generic; // 名前空間のインポート
class Program
{
    static void Main(string[] args)
    {
        Queue<int> myQueue = new Queue<int>(); // 整数型のQueueを宣言・初期化
    }
}

Enqueue()で要素を追加する

Enqueue()メソッドを使用すると、Queueに要素を追加できます。

以下の例では、整数をQueueに追加しています。

using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<int> myQueue = new Queue<int>();
        
        myQueue.Enqueue(1); // 1を追加
        myQueue.Enqueue(2); // 2を追加
        myQueue.Enqueue(3); // 3を追加
    }
}

Dequeue()で要素を取り出す

Dequeue()メソッドを使用すると、Queueの先頭から要素を取り出すことができます。

取り出した要素はQueueから削除されます。

以下の例では、要素を取り出して表示しています。

using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<int> myQueue = new Queue<int>();
        myQueue.Enqueue(1);
        myQueue.Enqueue(2);
        myQueue.Enqueue(3);
        
        int firstElement = myQueue.Dequeue(); // 先頭の要素を取り出す
        Console.WriteLine(firstElement); // 1が表示される
    }
}

Peek()で先頭の要素を確認する

Peek()メソッドを使用すると、Queueの先頭にある要素を確認できますが、取り出すことはありません。

以下の例では、先頭の要素を表示しています。

using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<int> myQueue = new Queue<int>();
        myQueue.Enqueue(1);
        myQueue.Enqueue(2);
        myQueue.Enqueue(3);
        
        int firstElement = myQueue.Peek(); // 先頭の要素を確認
        Console.WriteLine(firstElement); // 1が表示される
    }
}

Countプロパティで要素数を確認する

Countプロパティを使用すると、Queueに格納されている要素の数を確認できます。

以下の例では、要素数を表示しています。

using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<int> myQueue = new Queue<int>();
        myQueue.Enqueue(1);
        myQueue.Enqueue(2);
        myQueue.Enqueue(3);
        
        int numberOfElements = myQueue.Count; // 要素数を取得
        Console.WriteLine(numberOfElements); // 3が表示される
    }
}

Queueの操作例

要素を追加して取り出す基本例

以下の例では、Queueに要素を追加し、その後取り出す基本的な操作を示しています。

最初に追加した要素が最初に取り出されることを確認できます。

using System;
using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<string> myQueue = new Queue<string>();
        
        myQueue.Enqueue("A"); // Aを追加
        myQueue.Enqueue("B"); // Bを追加
        myQueue.Enqueue("C"); // Cを追加
        
        Console.WriteLine(myQueue.Dequeue()); // Aが表示される
        Console.WriteLine(myQueue.Dequeue()); // Bが表示される
        Console.WriteLine(myQueue.Dequeue()); // Cが表示される
    }
}

A
B
C

ループを使ったQueueの処理

ループを使用してQueueの全要素を処理することも可能です。

以下の例では、Queueの要素をすべて取り出して表示しています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<int> myQueue = new Queue<int>();
        
        myQueue.Enqueue(1);
        myQueue.Enqueue(2);
        myQueue.Enqueue(3);
        
        while (myQueue.Count > 0) // Queueが空でない限りループ
        {
            Console.WriteLine(myQueue.Dequeue()); // 要素を取り出して表示
        }
    }
}

1
2
3

空のQueueに対する操作の注意点

空のQueueに対してDequeue()やPeek()を呼び出すと、InvalidOperationExceptionが発生します。

以下の例では、空のQueueに対して操作を行い、例外が発生する様子を示しています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<int> myQueue = new Queue<int>(); // 空のQueueを作成
        
        try
        {
            Console.WriteLine(myQueue.Dequeue()); // 例外が発生
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine("Queueは空です: " + ex.Message); // エラーメッセージを表示
        }
    }
}

Queueは空です: Queue empty.

例外処理を使った安全なQueue操作

Queueを操作する際には、例外処理を用いて安全に操作を行うことが重要です。

以下の例では、Dequeue()を呼び出す前にQueueが空でないかを確認し、空であればエラーメッセージを表示します。

using System;
using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<int> myQueue = new Queue<int>();
        
        myQueue.Enqueue(1);
        
        if (myQueue.Count > 0) // Queueが空でないか確認
        {
            Console.WriteLine(myQueue.Dequeue()); // 要素を取り出して表示
        }
        else
        {
            Console.WriteLine("Queueは空です。"); // 空の場合のメッセージ
        }
    }
}

Queueの応用例

タスクの順番待ちに使う

Queueは、タスクの順番待ちを管理するのに非常に便利です。

例えば、プリンターのジョブ管理や、ユーザーからのリクエストを順番に処理する際に使用されます。

以下の例では、タスクをQueueに追加し、順番に処理する様子を示しています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<string> taskQueue = new Queue<string>();
        
        taskQueue.Enqueue("タスク1"); // タスクを追加
        taskQueue.Enqueue("タスク2");
        taskQueue.Enqueue("タスク3");
        
        while (taskQueue.Count > 0)
        {
            string task = taskQueue.Dequeue(); // タスクを取り出して処理
            Console.WriteLine(task + "を処理中..."); // 処理中のメッセージ
        }
    }
}

タスク1を処理中...
タスク2を処理中...
タスク3を処理中...

バッファリング処理に使う

Queueは、データのバッファリング処理にも利用されます。

例えば、データストリームからのデータを一時的に保存し、一定量が溜まったらまとめて処理することができます。

以下の例では、データをQueueに追加し、一定数に達したら処理を行います。

using System;
using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Queue<int> buffer = new Queue<int>();
        int bufferSize = 3; // バッファサイズ
        
        for (int i = 1; i <= 10; i++)
        {
            buffer.Enqueue(i); // データを追加
            
            if (buffer.Count >= bufferSize) // バッファが満杯になったら処理
            {
                Console.WriteLine("バッファ処理: " + string.Join(", ", buffer)); // バッファの内容を表示
                buffer.Clear(); // バッファをクリア
            }
        }
    }
}

バッファ処理: 1, 2, 3
バッファ処理: 4, 5, 6
バッファ処理: 7, 8, 9

幅優先探索(BFS)での利用

Queueは、幅優先探索(BFS)アルゴリズムにおいても重要な役割を果たします。

グラフやツリーの探索において、次に探索するノードを管理するためにQueueを使用します。

以下の例では、簡単なグラフを幅優先探索で探索する様子を示しています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
        Dictionary<string, List<string>> graph = new Dictionary<string, List<string>>()
        {
            { "A", new List<string> { "B", "C" } },
            { "B", new List<string> { "D", "E" } },
            { "C", new List<string> { "F" } },
            { "D", new List<string>() },
            { "E", new List<string>() },
            { "F", new List<string>() }
        };
        Queue<string> queue = new Queue<string>();
        queue.Enqueue("A"); // スタートノードを追加
        while (queue.Count > 0)
        {
            string node = queue.Dequeue(); // ノードを取り出す
            Console.WriteLine("訪問: " + node); // 訪問したノードを表示
            foreach (var neighbor in graph[node])
            {
                queue.Enqueue(neighbor); // 隣接ノードをQueueに追加
            }
        }
    }
}

訪問: A
訪問: B
訪問: C
訪問: D
訪問: E
訪問: F

マルチスレッド環境でのQueueの活用

Queueは、マルチスレッド環境においても非常に役立ちます。

スレッド間でのタスクの共有や、データの受け渡しに使用されます。

C#では、ConcurrentQueue<T>を使用することで、スレッドセーフなQueueを実現できます。

以下の例では、複数のスレッドがQueueにタスクを追加し、処理する様子を示しています。

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
class Program
{
    static void Main(string[] args)
    {
        ConcurrentQueue<int> taskQueue = new ConcurrentQueue<int>();
        
        // タスクを追加するスレッド
        Task.Run(() =>
        {
            for (int i = 1; i <= 5; i++)
            {
                taskQueue.Enqueue(i); // タスクを追加
                Console.WriteLine("タスク追加: " + i);
                Thread.Sleep(100); // 少し待つ
            }
        });
        // タスクを処理するスレッド
        Task.Run(() =>
        {
            while (true)
            {
                if (taskQueue.TryDequeue(out int task)) // タスクを取り出す
                {
                    Console.WriteLine("タスク処理: " + task); // 処理中のメッセージ
                }
                Thread.Sleep(150); // 少し待つ
            }
        });
        Console.ReadLine(); // 終了を待つ
    }
}

タスク追加: 1
タスク処理: 1
タスク追加: 2
タスク処理: 2
タスク追加: 3
タスク処理: 3
タスク追加: 4
タスク処理: 4
タスク追加: 5
タスク処理: 5

このように、Queueはさまざまな場面で活用され、効率的なデータ管理や処理を実現します。

Queueのパフォーマンスと制限

Queueの内部構造

C#のQueue<T>は、内部的に配列を使用して要素を管理しています。

要素が追加されると、必要に応じて配列のサイズが自動的に拡張されます。

このため、Queueは要素の追加や取り出しが非常に効率的です。

具体的には、Enqueue()メソッドは平均してO(1)の時間で要素を追加でき、Dequeue()メソッドも同様にO(1)の時間で要素を取り出すことができます。

ただし、配列のサイズが拡張される際にはO(n)の時間がかかることがあります。

メモリ効率とパフォーマンス

Queueは、要素を追加するたびに配列のサイズを調整するため、メモリの使用効率が重要です。

初期サイズが小さい場合、頻繁にサイズを変更する必要があるため、パフォーマンスが低下する可能性があります。

一般的には、Queueの初期サイズを適切に設定することで、メモリの再割り当てを減らし、パフォーマンスを向上させることができます。

また、Queueは要素の追加と取り出しが頻繁に行われる場合に特に効果的です。

大量のデータを扱う際の注意点

大量のデータをQueueで扱う場合、メモリの使用量やパフォーマンスに注意が必要です。

特に、Queueのサイズが大きくなると、メモリの消費が増加し、パフォーマンスが低下する可能性があります。

データの追加や取り出しが頻繁に行われる場合は、Queueの初期サイズを適切に設定し、必要に応じてデータを処理してQueueのサイズを管理することが重要です。

また、Queueが空でないかを確認する際には、Countプロパティを使用して、無駄な操作を避けることができます。

他のコレクションとの比較

Queueは、他のコレクション(例えば、List<T>やStack<T>)と比較して、特定の用途において優れたパフォーマンスを発揮します。

以下は、Queueと他のコレクションの比較です。

コレクション	特徴	主な用途
Queue<T>	先入れ先出し(FIFO)	タスクの順番待ち、バッファリング
Stack<T>	後入れ先出し(LIFO)	関数の呼び出し履歴、逆順処理
List<T>	インデックスによるアクセス	一般的なデータの格納、順序の保持

Queueは、特に順番待ちやバッファリングに適しており、他のコレクションと組み合わせて使用することで、より柔軟なデータ管理が可能になります。